/// <summary>
/// System.Drawing.BitmapからOpenCVのMatへ変換して返す.
/// </summary>
/// <param name="src">変換するSystem.Drawing.Bitmap</param>
/// <returns>変換結果のMat</returns>
#else
/// <summary>
/// Converts System.Drawing.Bitmap to Mat
/// </summary>
/// <param name="src">System.Drawing.Bitmap object to be converted</param>
/// <returns>A Mat object which is converted from System.Drawing.Bitmap</returns>
#endif
public static Mat ToMat(this Bitmap src)
{
if (src == null)
throw new ArgumentNullException("src");
int w = src.Width;
int h = src.Height;
int channels;
switch (src.PixelFormat)
{
case PixelFormat.Format24bppRgb:
case PixelFormat.Format32bppRgb:
channels = 3; break;
case PixelFormat.Format32bppArgb:
case PixelFormat.Format32bppPArgb:
channels = 4; break;
case PixelFormat.Format8bppIndexed:
case PixelFormat.Format1bppIndexed:
channels = 1; break;
default:
throw new NotImplementedException();
}
Mat dst = new Mat(h, w, MatType.CV_8UC(channels));
ToMat(src, dst);
return dst;
}
/// <summary>
///
/// </summary>
/// <param name="img"></param>
/// <param name="templ"></param>
/// <param name="results"></param>
/// <param name="cost"></param>
/// <param name="templScale"></param>
/// <param name="maxMatches"></param>
/// <param name="minMatchDistance"></param>
/// <param name="padX"></param>
/// <param name="padY"></param>
/// <param name="scales"></param>
/// <param name="minScale"></param>
/// <param name="maxScale"></param>
/// <param name="orientationWeight"></param>
/// <param name="truncate"></param>
/// <returns></returns>
public static int ChamferMatching(
Mat img, Mat templ,
out Point[][] results, out float[] cost,
double templScale=1, int maxMatches = 20,
double minMatchDistance = 1.0, int padX = 3,
int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6,
double orientationWeight = 0.5, double truncate = 20)
{
if (img == null)
throw new ArgumentNullException("img");
if (templ == null)
throw new ArgumentNullException("templ");
img.ThrowIfDisposed();
templ.ThrowIfDisposed();
using (var resultsVec = new VectorOfVectorPoint())
using (var costVec = new VectorOfFloat())
{
int ret = NativeMethods.contrib_chamerMatching(
img.CvPtr, templ.CvPtr, resultsVec.CvPtr, costVec.CvPtr,
templScale, maxMatches, minMatchDistance,
padX, padY, scales, minScale, maxScale, orientationWeight, truncate);
GC.KeepAlive(img);
GC.KeepAlive(templ);
results = resultsVec.ToArray();
cost = costVec.ToArray();
return ret;
}
}
private static void Main(string[] args)
{
Mat src = new Mat("data/tsukuba_left.png", LoadMode.GrayScale);
Mat dst20 = new Mat();
Mat dst40 = new Mat();
Mat dst44 = new Mat();
using (CLAHE clahe = Cv2.CreateCLAHE())
{
clahe.ClipLimit = 20;
clahe.Apply(src, dst20);
clahe.ClipLimit = 40;
clahe.Apply(src, dst40);
clahe.TilesGridSize = new Size(4, 4);
clahe.Apply(src, dst44);
}
Window.ShowImages(src, dst20, dst40, dst44);
/*var img1 = new IplImage("data/lenna.png", LoadMode.Color);
var img2 = new IplImage("data/match2.png", LoadMode.Color);
Surf(img1, img2);*/
//Mat[] mats = StitchingPreprocess(400, 400, 10);
//Stitching(mats);
//Track();
//Run();
}
private void updateImage()
{
var p = this.Dispatcher.BeginInvoke(new Action(() =>
{
try
{
this.jpegDec = new JpegBitmapDecoder(this.m_receivedMemory, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
this.bitmapsorce = this.jpegDec.Frames[0];
if (m_WritableBitmap == null)
{
this.m_WritableBitmap = new WriteableBitmap(this.bitmapsorce);
this.m_data = new byte[this.bitmapsorce.PixelWidth * this.bitmapsorce.PixelHeight * this.bitmapsorce.Format.BitsPerPixel / 8];
this.Image_Main.Source = this.m_WritableBitmap;
}
this.mat = new Mat(this.bitmapsorce.PixelWidth, this.bitmapsorce.PixelHeight, MatType.CV_8UC3, this.m_data);
Cv2.ImShow("Test" + this.TitleName, this.mat);
this.bitmapsorce.CopyPixels(this.m_data, this.bitmapsorce.PixelWidth * this.bitmapsorce.Format.BitsPerPixel / 8, 0);
this.m_WritableBitmap.WritePixels(new Int32Rect(0, 0, this.m_WritableBitmap.PixelWidth, this.m_WritableBitmap.PixelHeight), this.m_data, this.bitmapsorce.PixelWidth * this.bitmapsorce.Format.BitsPerPixel / 8, 0);
this.bitmapsorce = null;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}));
p.Wait();
}
//セットアップ
public KinectImage()
#region
{
//キネクト
this.kinect = KinectSensor.GetDefault();
//bodyIndexFrameの処理
this.bodyIndexFrameDes = this.kinect.BodyIndexFrameSource.FrameDescription;
this.bodyIndexFrameReader = this.kinect.BodyIndexFrameSource.OpenReader();
this.bodyIndexFrameReader.FrameArrived += this.BodyIndexFrame_Arrived;
//画像情報
this.kinectImgPackage = new ShadowPackage();
this.imageWidth = this.bodyIndexFrameDes.Width; // imgW;
this.imageHeight = this.bodyIndexFrameDes.Height; // imgH;
this.imageBytePerPixel = (int)this.bodyIndexFrameDes.BytesPerPixel;
this.bitmapRec = new Int32Rect(0, 0, this.imageWidth, this.imageHeight);
this.bitmapStride = (int)(this.imageWidth * this.imageBytePerPixel);
this.bodyIndexBuffer = new byte[this.imageWidth *
this.imageHeight * this.imageBytePerPixel];
this.kinectImage = new Mat(this.imageHeight, this.imageWidth, MatType.CV_8UC1);
//キネクト開始
this.kinect.Open();
}
private static Mat[] StitchingPreprocess(int width, int height, int count)
{
Mat source = new Mat(@"C:\Penguins.jpg", LoadMode.Color);
Mat result = source.Clone();
var rand = new Random();
var mats = new List<Mat>();
for (int i = 0; i < count; i++)
{
int x1 = rand.Next(source.Cols - width);
int y1 = rand.Next(source.Rows - height);
int x2 = x1 + width;
int y2 = y1 + height;
result.Line(new Point(x1, y1), new Point(x1, y2), new Scalar(0, 0, 255));
result.Line(new Point(x1, y2), new Point(x2, y2), new Scalar(0, 0, 255));
result.Line(new Point(x2, y2), new Point(x2, y1), new Scalar(0, 0, 255));
result.Line(new Point(x2, y1), new Point(x1, y1), new Scalar(0, 0, 255));
Mat m = source[new Rect(x1, y1, width, height)];
mats.Add(m.Clone());
//string outFile = String.Format(@"C:\temp\stitching\{0:D3}.png", i);
//m.SaveImage(outFile);
}
result.SaveImage(@"C:\temp\parts.png");
using (new Window(result))
{
Cv.WaitKey();
}
return mats.ToArray();
}
/// <summary>
/// Cannyアルゴリズムを用いて，画像のエッジを検出します．
/// </summary>
/// <param name="image">8ビット，シングルチャンネルの入力画像</param>
/// <param name="edges">出力されるエッジのマップ． image と同じサイズ，同じ型</param>
/// <param name="threshold1">ヒステリシスが存在する処理の，1番目の閾値</param>
/// <param name="threshold2">ヒステリシスが存在する処理の，2番目の閾値</param>
/// <param name="apertureSize">Sobelオペレータのアパーチャサイズ [既定値はApertureSize.Size3]</param>
/// <param name="L2gradient">画像勾配の強度を求めるために，より精度の高い L2ノルムを利用するか，L1ノルムで十分（false）かを指定します. [既定値はfalse]</param>
#else
/// <summary>
/// Finds edges in an image using Canny algorithm.
/// </summary>
/// <param name="image">Single-channel 8-bit input image</param>
/// <param name="edges">The output edge map. It will have the same size and the same type as image</param>
/// <param name="threshold1">The first threshold for the hysteresis procedure</param>
/// <param name="threshold2">The second threshold for the hysteresis procedure</param>
/// <param name="apertureSize">Aperture size for the Sobel operator [By default this is ApertureSize.Size3]</param>
/// <param name="L2gradient">Indicates, whether the more accurate L2 norm should be used to compute the image gradient magnitude (true), or a faster default L1 norm is enough (false). [By default this is false]</param>
#endif
public static void Canny(Mat image, Mat edges, double threshold1, double threshold2, ApertureSize apertureSize = ApertureSize.Size3, bool L2gradient = false)
{
if (image == null)
throw new ArgumentNullException("image");
if (edges == null)
throw new ArgumentNullException("edges");
CppInvoke.cv_Canny(image.CvPtr, edges.CvPtr, threshold1, threshold2, apertureSize, L2gradient);
}
public Mat Filter(Mat src)
{
var dst = new Mat();
using (var k = GetMat())
{
Cv2.Filter2D(src, dst, MatType.CV_8U, k);
return dst;
}
}
/// <summary>
/// 与えられたデータセットの最近傍探索インデックスを作成します．
/// </summary>
/// <param name="features">インデックス作成対象となる特徴（点）が格納された， CV_32F 型の行列．この行列のサイズは matrix is num _ features x feature _ dimensionality となります</param>
/// <param name="params">params – インデックスパラメータを含む構造体．作成されるインデックスの種類は，このパラメータの種類に依存します</param>
#else
/// <summary>
/// Constructs a nearest neighbor search index for a given dataset.
/// </summary>
/// <param name="features">features – Matrix of type CV _ 32F containing the features(points) to index. The size of the matrix is num _ features x feature _ dimensionality.</param>
/// <param name="params">Structure containing the index parameters. The type of index that will be constructed depends on the type of this parameter. </param>
#endif
public Index(Mat features, IndexParams @params)
{
if (features == null)
throw new ArgumentNullException("features");
if (@params == null)
throw new ArgumentNullException("params");
ptr = NativeMethods.flann_Index_construct(features.CvPtr, @params.CvPtr);
if (ptr == IntPtr.Zero)
throw new OpenCvSharpException("Failed to create Index");
}
public Task<Mat> FilterAsync(Mat src)
{
return Task.Run(() =>
{
var dst = new Mat();
using (var k = GetMat())
{
Cv2.Filter2D(src, dst, MatType.CV_8U, k);
return dst;
}
});
}
private static void Run()
{
var dm = DescriptorMatcher.Create("BruteForce");
dm.Clear();
Console.WriteLine(Cv2.GetCudaEnabledDeviceCount());
string[] algoNames = Algorithm.GetList();
Console.WriteLine(String.Join("\n", algoNames));
SIFT al1 = Algorithm.Create<SIFT>("Feature2D.SIFT");
string[] ppp = al1.GetParams();
Console.WriteLine(ppp);
var t = al1.ParamType("contrastThreshold");
double d = al1.GetDouble("contrastThreshold");
t.ToString();
d.ToString();
var src = new Mat("img/lenna.png");
var rand = new Random();
var memory = new List<long>(100);
var a1 = new Mat(src, Rect.FromLTRB(0, 0, 30, 40));
var a2 = new Mat(src, Rect.FromLTRB(0, 0, 30, 40));
var a3 = new Mat(src, Rect.FromLTRB(0, 0, 30, 40));
a3.ToString();
for (long i = 0;; i++)
{
SIFT a = Algorithm.Create<SIFT>("Feature2D.SIFT");
a.ToString();
for (int j = 0; j < 200; j++)
{
int c1 = rand.Next(100, 400);
int c2 = rand.Next(100, 400);
Mat temp = src.Row[c1];
src.Row[c1] = src.Row[c2];
src.Row[c2] = temp;
}
memory.Add(MyProcess.WorkingSet64);
if (memory.Count >= 100)
{
double average = memory.Average();
Console.WriteLine("{0:F3}MB", average / 1024.0 / 1024.0);
memory.Clear();
GC.Collect();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="mat"></param>
internal MatExpr(Mat mat)
{
if(mat == null)
throw new ArgumentNullException("mat");
try
{
this.ptr = NativeMethods.core_MatExpr_new(mat.CvPtr);
}
catch (BadImageFormatException ex)
{
throw PInvokeHelper.CreateException(ex);
}
}
public static void ConvertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, MatrixType dstmap1type, bool nninterpolation = false)
{
if (map1 == null)
throw new ArgumentNullException("map1");
if (map2 == null)
throw new ArgumentNullException("map2");
if (dstmap1 == null)
throw new ArgumentNullException("dstmap1");
if (dstmap2 == null)
throw new ArgumentNullException("dstmap2");
CppInvoke.cv_convertMaps(map1.CvPtr, map2.CvPtr, dstmap1.CvPtr, dstmap2.CvPtr, dstmap1type, nninterpolation);
}
/// <summary>
/// WriteableBitmapをMatに変換する
/// </summary>
/// <param name="src">変換するWriteableBitmap</param>
/// <returns>OpenCvSharpで扱えるMat</returns>
#else
/// <summary>
/// Converts WriteableBitmap to Mat
/// </summary>
/// <param name="src">Input WriteableBitmap</param>
/// <returns>IplImage</returns>
#endif
public static Mat ToMat(this WriteableBitmap src)
{
if (src == null)
{
throw new ArgumentNullException("src");
}
int w = src.PixelWidth;
int h = src.PixelHeight;
MatType type = GetOptimumType(src.Format);
Mat dst = new Mat(h, w, type);
ToMat(src, dst);
return dst;
}
/// <summary>
/// Displays the image in the specified window
/// </summary>
/// <param name="winname">Name of the window.</param>
/// <param name="mat">Image to be shown.</param>
public static void ImShow(string winname, Mat mat)
{
if (string.IsNullOrEmpty(winname))
throw new ArgumentNullException("winname");
if (mat == null)
throw new ArgumentNullException("mat");
try
{
NativeMethods.highgui_imshow(winname, mat.CvPtr);
}
catch (BadImageFormatException ex)
{
throw PInvokeHelper.CreateException(ex);
}
}
public static ImageData Filter(string fileName, SpatialFilterKernel kernel)
{
try
{
var src = new Mat(fileName);
var bmp = kernel.FilterWriteableBitmap(src);
var images = new ImageData();
images.SourceImage = src.ToWriteableBitmap();
images.ResultImage = bmp;
return images;
}
finally
{
}
}
/// <summary>
/// converts rotation vector to rotation matrix using Rodrigues transformation
/// </summary>
/// <param name="vector">Input rotation vector (3x1).</param>
/// <param name="matrix">Output rotation matrix (3x3).</param>
/// <param name="jacobian">Optional output Jacobian matrix, 3x9, which is a matrix of partial derivatives of the output array components with respect to the input array components.</param>
public static void Rodrigues(double[] vector, out double[,] matrix, out double[,] jacobian)
{
if (vector == null)
throw new ArgumentNullException("vector");
if (vector.Length != 3)
throw new ArgumentException("vector.Length != 3");
using (var vectorM = new Mat(3, 1, MatType.CV_64FC1, vector))
using (var matrixM = new MatOfDouble())
using (var jacobianM = new MatOfDouble())
{
NativeMethods.calib3d_Rodrigues_VecToMat(vectorM.CvPtr, matrixM.CvPtr, jacobianM.CvPtr);
matrix = matrixM.ToRectangularArray();
jacobian = jacobianM.ToRectangularArray();
}
}
/// <summary>
/// converts rotation matrix to rotation vector using Rodrigues transformation
/// </summary>
/// <param name="matrix">Input rotation matrix (3x3).</param>
/// <param name="vector">Output rotation vector (3x1).</param>
/// <param name="jacobian">Optional output Jacobian matrix, 3x9, which is a matrix of partial derivatives of the output array components with respect to the input array components.</param>
public static void Rodrigues(double[,] matrix, out double[] vector, out double[,] jacobian)
{
if (matrix == null)
throw new ArgumentNullException("matrix");
if (matrix.GetLength(0) != 3 || matrix.GetLength(1) != 3)
throw new ArgumentException("matrix must be double[3,3]");
using (var matrixM = new Mat(3, 3, MatType.CV_64FC1, matrix))
using (var vectorM = new MatOfDouble())
using (var jacobianM = new MatOfDouble())
{
NativeMethods.calib3d_Rodrigues_MatToVec(matrixM.CvPtr, vectorM.CvPtr, jacobianM.CvPtr);
vector = vectorM.ToArray();
jacobian = jacobianM.ToRectangularArray();
}
}
public void SetStreamFrame(Mat frame, string text)
{
using (var bitmap = frame.ToBitmap())
using (var graphics = Graphics.FromImage(bitmap))
{
var h = bitmap.Height / 2;
var w = bitmap.Width / 2;
graphics.DrawRectangle(Pens.Crimson, Config.MainX - Config.MainXDelta, h, 2 * Config.MainXDelta, h);
graphics.DrawRectangle(Pens.Chartreuse, 0, h, w - 20, h);
streamBox.Image = new Bitmap(bitmap, streamBox.Size);
}
cameraInfo.Invoke((MethodInvoker)(() => cameraInfo.Text = text));
}
/// <summary>
/// Draw keypoints.
/// </summary>
/// <param name="image"></param>
/// <param name="keypoints"></param>
/// <param name="outImage"></param>
/// <param name="color"></param>
/// <param name="flags"></param>
public static void DrawKeypoints(Mat image, IEnumerable<KeyPoint> keypoints, Mat outImage,
Scalar? color = null, DrawMatchesFlags flags = DrawMatchesFlags.Default)
{
if (image == null)
throw new ArgumentNullException("image");
if (outImage == null)
throw new ArgumentNullException("outImage");
if (keypoints == null)
throw new ArgumentNullException("keypoints");
image.ThrowIfDisposed();
outImage.ThrowIfDisposed();
KeyPoint[] keypointsArray = EnumerableEx.ToArray(keypoints);
Scalar color0 = color.GetValueOrDefault(Scalar.All(-1));
NativeMethods.features2d_drawKeypoints(image.CvPtr, keypointsArray, keypointsArray.Length,
outImage.CvPtr, color0, (int)flags);
}
private static void Stitching(Mat[] images)
{
var stitcher = Stitcher.CreateDefault(false);
Mat pano = new Mat();
Console.Write("Stitching 処理開始...");
var status = stitcher.Stitch(images, pano);
Console.WriteLine(" 完了 {0}", status);
pano.SaveImage(@"C:\temp\pano.png");
Window.ShowImages(pano);
foreach (Mat image in images)
{
image.Dispose();
}
}
public KinectDevice()
{
//kinect設定
this.kinect = KinectSensor.GetDefault();
//設定とハンドラ
//colorImage
#region
this.colorImageFormat = ColorImageFormat.Bgra;
this.colorFrameDescription = this.kinect.ColorFrameSource.CreateFrameDescription(this.colorImageFormat);
this.colorFrameReader = this.kinect.ColorFrameSource.OpenReader();
this.colorFrameReader.FrameArrived += ColorFrame_Arrived;
this.colors = new byte[this.colorFrameDescription.Width
* this.colorFrameDescription.Height
* this.colorFrameDescription.BytesPerPixel];
#endregion
//骨格情報
#region
this.bodyFrameReader = this.kinect.BodyFrameSource.OpenReader();
this.bodyFrameReader.FrameArrived += BodyFrame_Arrived;
#endregion
//震度情報
#region
this.depthFrameReader = this.kinect.DepthFrameSource.OpenReader();
this.depthFrameReader.FrameArrived += DepthFrame_Arrived;
this.depthFrameDescription = this.kinect.DepthFrameSource.FrameDescription;
this.depthBuffer = new ushort[this.depthFrameDescription.LengthInPixels];
#endregion
//BodyIndex
#region
this.bodyIndexFrameDes = this.kinect.BodyIndexFrameSource.FrameDescription;
this.bodyIndexFrameReader = this.kinect.BodyIndexFrameSource.OpenReader();
this.bodyIndexFrameReader.FrameArrived += this.BodyIndexFrame_Arrived;
this.bodyIndexBuffer = new byte[this.bodyIndexFrameDes.Width *
this.bodyIndexFrameDes.Height * this.bodyIndexFrameDes.BytesPerPixel];
#endregion
//kinect開始
this.package = new ShadowPackage();
this.imageWidth = this.bodyIndexFrameDes.Width;
this.imageHeight = this.bodyIndexFrameDes.Height;
this.imageBytePerPixel = (int)this.bodyIndexFrameDes.BytesPerPixel;
this.kinectImage = new Mat(this.imageHeight, this.imageWidth, MatType.CV_8UC1);
this.kinect.Open();
}
private static void Surf(IplImage img1, IplImage img2)
{
Mat src = new Mat(img1, true);
Mat src2 = new Mat(img2, true);
//Detect the keypoints and generate their descriptors using SURF
SURF surf = new SURF(500, 4, 2, true);
KeyPoint[] keypoints1, keypoints2;
MatOfFloat descriptors1 = new MatOfFloat();
MatOfFloat descriptors2 = new MatOfFloat();
surf.Run(src, null, out keypoints1, descriptors1);
surf.Run(src2, null, out keypoints2, descriptors2);
// Matching descriptor vectors with a brute force matcher
BFMatcher matcher = new BFMatcher(NormType.L2, false);
DMatch[] matches = matcher.Match(descriptors1, descriptors2);//例外が発生する箇所
Mat view = new Mat();
Cv2.DrawMatches(src, keypoints1, src2, keypoints2, matches, view);
Window.ShowImages(view);
}
/// <summary>
/// 高速なマルチスケール Hesian 検出器を用いて keypoint を検出します．
/// </summary>
/// <param name="img"></param>
/// <param name="mask"></param>
/// <returns></returns>
#else
/// <summary>
/// detects keypoints using fast multi-scale Hessian detector
/// </summary>
/// <param name="img"></param>
/// <param name="mask"></param>
/// <returns></returns>
#endif
public KeyPoint[] Extract(Mat img, Mat mask)
{
if (img == null)
throw new ArgumentNullException("img");
CvMat imgMat = img.ToCvMat();
CvMat maskMat = (mask == null) ? null : mask.ToCvMat();
CvSURFPoint[] keypoints;
float[][] descriptors;
Cv.ExtractSURF(imgMat, maskMat, out keypoints, out descriptors, this);
KeyPoint[] result = new KeyPoint[keypoints.Length];
for (int i = 0; i < result.Length; i++)
{
CvSURFPoint kpt = keypoints[i];
result[i] = new KeyPoint(kpt.Pt, (float) kpt.Size, kpt.Dir, kpt.Hessian, GetPointOctave(kpt, this));
}
return result;
}
/// <summary>
/// Performs object detection with a multi-scale window.
/// </summary>
/// <param name="img">Source image. CV_8UC1 and CV_8UC4 types are supported for now.</param>
/// <param name="foundWeights"></param>
/// <param name="hitThreshold">Threshold for the distance between features and SVM classifying plane.</param>
/// <param name="winStride">Window stride. It must be a multiple of block stride.</param>
/// <param name="padding">Mock parameter to keep the CPU interface compatibility. It must be (0,0).</param>
/// <param name="scale">Coefficient of the detection window increase.</param>
/// <param name="groupThreshold">Coefficient to regulate the similarity threshold.
/// When detected, some objects can be covered by many rectangles. 0 means not to perform grouping.</param>
/// <returns>Detected objects boundaries.</returns>
public virtual Rect[] DetectMultiScale(Mat img, out double[] foundWeights,
double hitThreshold = 0, Size? winStride = null, Size? padding = null, double scale = 1.05, int groupThreshold = 2)
{
if (disposed)
throw new ObjectDisposedException("HOGDescriptor");
if (img == null)
throw new ArgumentNullException("img");
img.ThrowIfDisposed();
Size winStride0 = winStride.GetValueOrDefault(new Size());
Size padding0 = padding.GetValueOrDefault(new Size());
using (var flVec = new VectorOfRect())
using (var foundWeightsVec = new VectorOfDouble())
{
NativeMethods.objdetect_HOGDescriptor_detectMultiScale(ptr, img.CvPtr, flVec.CvPtr, foundWeightsVec.CvPtr,
hitThreshold, winStride0, padding0, scale, groupThreshold);
foundWeights = foundWeightsVec.ToArray();
return flVec.ToArray();
}
}
/// <summary>
/// Performs object detection without a multi-scale window.
/// </summary>
/// <param name="img">Source image. CV_8UC1 and CV_8UC4 types are supported for now.</param>
/// <param name="weights"></param>
/// <param name="hitThreshold">Threshold for the distance between features and SVM classifying plane.
/// Usually it is 0 and should be specfied in the detector coefficients (as the last free coefficient).
/// But if the free coefficient is omitted (which is allowed), you can specify it manually here.</param>
/// <param name="winStride">Window stride. It must be a multiple of block stride.</param>
/// <param name="padding">Mock parameter to keep the CPU interface compatibility. It must be (0,0).</param>
/// <param name="searchLocations"></param>
/// <returns>Left-top corner points of detected objects boundaries.</returns>
public virtual Point[] Detect(Mat img, out double[] weights,
double hitThreshold = 0, Size? winStride = null, Size? padding = null, Point[] searchLocations = null)
{
if (disposed)
throw new ObjectDisposedException("HOGDescriptor");
if (img == null)
throw new ArgumentNullException("img");
img.ThrowIfDisposed();
Size winStride0 = winStride.GetValueOrDefault(new Size());
Size padding0 = padding.GetValueOrDefault(new Size());
using (var flVec = new VectorOfPoint())
using (var weightsVec = new VectorOfDouble())
{
int slLength = (searchLocations != null) ? searchLocations.Length : 0;
NativeMethods.objdetect_HOGDescriptor_detect(ptr, img.CvPtr, flVec.CvPtr, weightsVec.CvPtr,
hitThreshold, winStride0, padding0, searchLocations, slLength);
weights = weightsVec.ToArray();
return flVec.ToArray();
}
}
/// <summary>
///
/// </summary>
/// <param name="img"></param>
/// <param name="winStride"></param>
/// <param name="padding"></param>
/// <param name="locations"></param>
/// <returns></returns>
public virtual float[] Compute(Mat img, Size? winStride = null, Size? padding = null, Point[] locations = null)
{
if (disposed)
throw new ObjectDisposedException("HOGDescriptor");
if (img == null)
throw new ArgumentNullException("img");
Size winStride0 = winStride.GetValueOrDefault(new Size());
Size padding0 = padding.GetValueOrDefault(new Size());
using (var flVec = new VectorOfFloat())
{
int length = (locations != null) ? locations.Length : 0;
NativeMethods.objdetect_HOGDescriptor_compute(ptr, img.CvPtr, flVec.CvPtr, winStride0, padding0, locations, length);
return flVec.ToArray();
}
}
internal Indexer(Mat parent)
: base(parent)
{
this.ptr = (byte *)parent.Data.ToPointer();
}
/// <summary>
/// Matオブジェクトから初期化
/// </summary>
/// <param name="mat">Matオブジェクト</param>
#else
/// <summary>
/// Initializes by Mat object
/// </summary>
/// <param name="mat">Managed Mat object</param>
#endif
public MatOfByte(Mat mat)
: base(mat)
{
}
/// <summary>
/// Creates/Sets a matrix header for the specified row/column span.
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="value"></param>
public virtual void Set(int start, int end, Mat value)
{
this[start, end] = value;
}
/// <summary>
/// evaluate specified ROI and return confidence value for each location in multiple scales
/// </summary>
/// <param name="img"></param>
/// <param name="foundLocations"></param>
/// <param name="locations"></param>
/// <param name="hitThreshold"></param>
/// <param name="groupThreshold"></param>
public void DetectMultiScaleROI(
Mat img,
out Rect[] foundLocations,
out DetectionROI[] locations,
double hitThreshold = 0,
int groupThreshold = 0)
{
if (disposed)
throw new ObjectDisposedException("HOGDescriptor");
if (img == null)
throw new ArgumentNullException("img");
img.ThrowIfDisposed();
using (var flVec = new VectorOfRect())
using (var scalesVec = new VectorOfDouble())
using (var locationsVec = new VectorOfVectorPoint())
using (var confidencesVec = new VectorOfVectorDouble())
{
NativeMethods.objdetect_HOGDescriptor_detectMultiScaleROI(
ptr, img.CvPtr, flVec.CvPtr,
scalesVec.CvPtr, locationsVec.CvPtr, confidencesVec.CvPtr,
hitThreshold, groupThreshold);
foundLocations = flVec.ToArray();
double[] s = scalesVec.ToArray();
Point[][] l = locationsVec.ToArray();
double[][] c = confidencesVec.ToArray();
if(s.Length != l.Length || l.Length != c.Length)
throw new OpenCvSharpException("Invalid result data 'locations'");
locations = new DetectionROI[s.Length];
for (int i = 0; i < s.Length; i++)
{
locations[i] = new DetectionROI
{
Scale = s[i],
Locations = l[i],
Confidences = c[i]
};
}
}
}
/// <summary>
/// Creates/Sets a matrix header for the specified matrix row/column.
/// </summary>
/// <param name="pos"></param>
/// <param name="value"></param>
public virtual void Set(int pos, Mat value)
{
this[pos] = value;
}
/// <summary>
/// Matオブジェクトから初期化
/// </summary>
/// <param name="mat">Matオブジェクト</param>
#else
/// <summary>
/// Initializes by Mat object
/// </summary>
/// <param name="mat">Managed Mat object</param>
#endif
public MatOfInt4(Mat mat)
: base(mat)
{
}
/// <summary>
/// Matオブジェクトから初期化
/// </summary>
/// <param name="mat">Matオブジェクト</param>
#else
/// <summary>
/// Initializes by Mat object
/// </summary>
/// <param name="mat">Managed Mat object</param>
#endif
public MatOfUShort(Mat mat)
: base(mat.CvPtr)
{
}
/// <summary>
/// Matオブジェクトから初期化
/// </summary>
/// <param name="mat">Matオブジェクト</param>
#else
/// <summary>
/// Initializes by Mat object
/// </summary>
/// <param name="mat">Managed Mat object</param>
#endif
public MatOfDMatch(Mat mat)
: base(mat)
{
}
/// <summary>
///
/// </summary>
/// <param name="img"></param>
/// <param name="grad"></param>
/// <param name="angleOfs"></param>
/// <param name="paddingTL"></param>
/// <param name="paddingBR"></param>
public virtual void ComputeGradient(Mat img, Mat grad, Mat angleOfs, Size? paddingTL = null, Size? paddingBR = null)
{
if (disposed)
throw new ObjectDisposedException("HOGDescriptor");
if (img == null)
throw new ArgumentNullException("img");
if (grad == null)
throw new ArgumentNullException("grad");
if (angleOfs == null)
throw new ArgumentNullException("angleOfs");
img.ThrowIfDisposed();
grad.ThrowIfDisposed();
angleOfs.ThrowIfDisposed();
Size paddingTL0 = paddingTL.GetValueOrDefault(new Size());
Size paddingBR0 = paddingBR.GetValueOrDefault(new Size());
NativeMethods.objdetect_HOGDescriptor_computeGradient(ptr, img.CvPtr, grad.CvPtr, angleOfs.CvPtr, paddingTL0, paddingBR0);
}
/// <summary>
///
/// </summary>
/// <param name="parent"></param>
protected internal MatRowColIndexer(Mat parent)
{
this.parent = parent;
}
/// <summary>
/// evaluate specified ROI and return confidence value for each location
/// </summary>
/// <param name="img"></param>
/// <param name="locations"></param>
/// <param name="foundLocations"></param>
/// <param name="confidences"></param>
/// <param name="hitThreshold"></param>
/// <param name="winStride"></param>
/// <param name="padding"></param>
public void DetectROI(
Mat img, Point[] locations, out Point[] foundLocations, out double[] confidences,
double hitThreshold = 0, Size? winStride = null, Size? padding = null)
{
if (disposed)
throw new ObjectDisposedException("HOGDescriptor");
if (img == null)
throw new ArgumentNullException("img");
if (locations == null)
throw new ArgumentNullException("locations");
img.ThrowIfDisposed();
Size winStride0 = winStride.GetValueOrDefault(new Size());
Size padding0 = padding.GetValueOrDefault(new Size());
using (var flVec = new VectorOfPoint())
using (var cVec = new VectorOfDouble())
{
NativeMethods.objdetect_HOGDescriptor_detectROI(ptr, img.CvPtr, locations, locations.Length,
flVec.CvPtr, cVec.CvPtr, hitThreshold, winStride0, padding0);
foundLocations = flVec.ToArray();
confidences = cVec.ToArray();
}
}
/// <summary>
/// Creates/Sets a matrix header for the specified row/column span.
/// </summary>
/// <param name="range"></param>
/// <param name="value"></param>
public virtual void Set(Range range, Mat value)
{
this[range.Start, range.End] = value;
}
/// <summary>
/// StarDetectorアルゴリズムによりキーポイントを取得する
/// </summary>
/// <param name="image">8ビット グレースケールの入力画像</param>
/// <returns></returns>
#else
/// <summary>
/// Retrieves keypoints using the StarDetector algorithm.
/// </summary>
/// <param name="image">The input 8-bit grayscale image</param>
/// <returns></returns>
#endif
public KeyPoint[] Run(Mat image)
{
if (image == null)
throw new ArgumentNullException("image");
image.ThrowIfDisposed();
IntPtr keypoints;
NativeMethods.features2d_StarDetector_detect(ptr, image.CvPtr, out keypoints);
using (VectorOfKeyPoint keypointsVec = new VectorOfKeyPoint(keypoints))
{
return keypointsVec.ToArray();
}
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
/// <param name="mask"></param>
/// <returns></returns>
public KeyPoint[] Run(Mat image, Mat mask)
{
ThrowIfDisposed();
return(base.Detect(image, mask));
}
