///<summary>
///Performs a convolution using the specific <paramref name="kernel"/>
///</summary>
///<param name="kernel">The convolution kernel</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
///<returns>The result of the convolution</returns>
public GpuImage <TColor, TDepth> Convolution(ConvolutionKernelF kernel, Stream stream)
{
GpuImage <TColor, TDepth> result = new GpuImage <TColor, TDepth>(Size);
using (GpuLinearFilter <TColor, TDepth> linearFilter = new GpuLinearFilter <TColor, TDepth>(kernel, kernel.Center, CvEnum.BORDER_TYPE.REFLECT101, new MCvScalar()))
{
linearFilter.Apply(this, result, stream);
}
return(result);
}
/// <summary>
/// Perfroms object detection with increasing detection window.
/// </summary>
/// <param name="image">The GpuImage to search in</param>
/// <param name="hitThreshold">The threshold for the distance between features and classifying plane.</param>
/// <param name="winStride">Window stride. Must be a multiple of block stride.</param>
/// <param name="padding">Mock parameter to keep CPU interface compatibility. Must be (0,0).</param>
/// <param name="scale">Coefficient of the detection window increase.</param>
/// <param name="groupThreshold">After detection some objects could be covered by many rectangles. This coefficient regulates similarity threshold. 0 means don't perform grouping.</param>
/// <returns>The regions where positives are found</returns>
public Rectangle[] DetectMultiScale(
GpuImage <Gray, Byte> image,
double hitThreshold,
Size winStride,
Size padding,
double scale,
int groupThreshold)
{
gpuHOGDescriptorDetectMultiScale(_ptr, image, _rectSeq, hitThreshold, winStride, padding, scale, groupThreshold);
return(_rectSeq.ToArray());
}
///<summary>
///Split current Image into an array of gray scale images where each element
///in the array represent a single color channel of the original image
///</summary>
///<returns>
///An array of gray scale images where each element
///in the array represent a single color channel of the original image
///</returns>
public new GpuImage <Gray, TDepth>[] Split()
{
GpuImage <Gray, TDepth>[] result = new GpuImage <Gray, TDepth> [NumberOfChannels];
Size size = Size;
for (int i = 0; i < result.Length; i++)
{
result[i] = new GpuImage <Gray, TDepth>(size);
}
SplitInto(result);
return(result);
}
/// <summary>
/// Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
/// </summary>
/// <param name="image">The image where search will take place</param>
/// <param name="scaleFactor">The factor by which the search window is scaled between the subsequent scans, for example, 1.1 means increasing window by 10%. Use 1.2 for default.</param>
/// <param name="minNeighbors">Minimum number (minus 1) of neighbor rectangles that makes up an object. All the groups of a smaller number of rectangles than min_neighbors-1 are rejected. If min_neighbors is 0, the function does not any grouping at all and returns all the detected candidate rectangles, which may be useful if the user wants to apply a customized grouping procedure. Use 4 for default.</param>
/// <param name="minSize">Minimum window size. By default, it is set to the size of samples the classifier has been trained on (~20x20 for face detection). Use Size.Empty for default</param>
/// <returns>An array of regions for the detected objects</returns>
public Rectangle[] DetectMultiScale <TColor>(GpuImage <TColor, Byte> image, double scaleFactor, int minNeighbors, Size minSize) where TColor : struct, IColor
{
try
{
Seq <Rectangle> regions = new Seq <Rectangle>(_stor);
int count = gpuCascadeClassifierDetectMultiScale(_ptr, image, _buffer, scaleFactor, minNeighbors, minSize, regions);
if (count == 0)
{
return(new Rectangle[0]);
}
Rectangle[] result = regions.ToArray();
return(result);
}
finally
{
_stor.Clear();
}
}
/// <summary>
/// Compute the dense optical flow.
/// </summary>
/// <param name="frame0">Source frame</param>
/// <param name="frame1">Frame to track (with the same size as <paramref name="frame0"/>)</param>
/// <param name="u">Flow horizontal component (along x axis)</param>
/// <param name="v">Flow vertical component (along y axis)</param>
public void Dense(GpuImage <Gray, byte> frame0, GpuImage <Gray, byte> frame1, GpuImage <Gray, float> u, GpuImage <Gray, float> v)
{
GpuInvoke.gpuPryLKOpticalFlowDense(_ptr, frame0, frame1, u, v, IntPtr.Zero);
}
/// <summary>
/// Compute the optical flow.
/// </summary>
/// <param name="frame0">Source frame</param>
/// <param name="frame1">Frame to track (with the same size as <paramref name="frame0"/>)</param>
/// <param name="u">Flow horizontal component (along x axis)</param>
/// <param name="v">Flow vertical component (along y axis)</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
public void Compute(GpuImage <Gray, float> frame0, GpuImage <Gray, float> frame1, GpuImage <Gray, Byte> u, GpuImage <Gray, Byte> v, Stream stream)
{
GpuInvoke.gpuBroxOpticalFlowCompute(_ptr, frame0, frame1, u, v, stream);
}
/// <summary>
/// Perfroms object detection with increasing detection window.
/// </summary>
/// <param name="image">The GpuImage to search in</param>
/// <returns>The regions where positives are found</returns>
public Rectangle[] DetectMultiScale(GpuImage <Gray, Byte> image)
{
return(DetectMultiScale(image, 0, new Size(8, 8), new Size(0, 0), 1.05, 2));
}
/// <summary>
/// Compute the keypoints and descriptors given the image
/// </summary>
/// <param name="image">The image where the keypoints and descriptors will be computed from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <param name="descriptors">The resulting descriptors</param>
/// <param name="keyPoints">The resulting keypoints</param>
public void ComputeRaw(GpuImage <Gray, Byte> image, GpuImage <Gray, byte> mask, out GpuMat <float> keyPoints, out GpuMat <Byte> descriptors)
{
keyPoints = new GpuMat <float>();
descriptors = new GpuMat <byte>();
GpuInvoke.gpuORBDetectorCompute(_ptr, image, mask, keyPoints, descriptors);
}
/// <summary>
/// Create a GpuImage from the specific region of <paramref name="image"/>. The data is shared between the two GpuImage
/// </summary>
/// <param name="image">The GpuImage where the region is extracted from</param>
/// <param name="colRange">The column range. Use MCvSlice.WholeSeq for all columns.</param>
/// <param name="rowRange">The row range. Use MCvSlice.WholeSeq for all rows.</param>
public GpuImage(GpuImage <TColor, TDepth> image, MCvSlice rowRange, MCvSlice colRange)
: this(GpuInvoke.GpuMatGetRegion(image, rowRange, colRange))
{
}
/// <summary>
/// Convert the source image to the current image, if the size are different, the current image will be a resized version of the srcImage.
/// </summary>
/// <typeparam name="TSrcColor">The color type of the source image</typeparam>
/// <typeparam name="TSrcDepth">The color depth of the source image</typeparam>
/// <param name="srcImage">The sourceImage</param>
public void ConvertFrom <TSrcColor, TSrcDepth>(GpuImage <TSrcColor, TSrcDepth> srcImage)
where TSrcColor : struct, IColor
where TSrcDepth : new()
{
if (!Size.Equals(srcImage.Size))
{ //if the size of the source image do not match the size of the current image
using (GpuImage <TSrcColor, TSrcDepth> tmp = srcImage.Resize(Size, Emgu.CV.CvEnum.INTER.CV_INTER_LINEAR, null))
{
ConvertFrom(tmp);
return;
}
}
if (typeof(TColor) == typeof(TSrcColor))
{
#region same color
if (typeof(TDepth) == typeof(TSrcDepth)) //same depth
{
GpuInvoke.Copy(srcImage.Ptr, Ptr, IntPtr.Zero);
}
else //different depth
{
if (typeof(TDepth) == typeof(Byte) && typeof(TSrcDepth) != typeof(Byte))
{
double[] minVal, maxVal;
Point[] minLoc, maxLoc;
srcImage.MinMax(out minVal, out maxVal, out minLoc, out maxLoc);
double min = minVal[0];
double max = maxVal[0];
for (int i = 1; i < minVal.Length; i++)
{
min = Math.Min(min, minVal[i]);
max = Math.Max(max, maxVal[i]);
}
double scale = 1.0, shift = 0.0;
if (max > 255.0 || min < 0)
{
scale = (max == min) ? 0.0 : 255.0 / (max - min);
shift = (scale == 0) ? min : -min * scale;
}
GpuInvoke.ConvertTo(srcImage.Ptr, Ptr, scale, shift);
}
else
{
GpuInvoke.ConvertTo(srcImage.Ptr, Ptr, 1.0, 0.0);
}
}
#endregion
}
else
{
#region different color
if (typeof(TDepth) == typeof(TSrcDepth))
{ //same depth
ConvertColor(srcImage.Ptr, Ptr, typeof(TSrcColor), typeof(TColor), Size, null);
}
else
{ //different depth
using (GpuImage <TSrcColor, TDepth> tmp = srcImage.Convert <TSrcColor, TDepth>()) //convert depth
ConvertColor(tmp.Ptr, Ptr, typeof(TSrcColor), typeof(TColor), Size, null);
}
#endregion
}
}
/// <summary>
/// Apply the filter to the disparity image
/// </summary>
/// <param name="disparity">The input disparity map</param>
/// <param name="image">The image</param>
/// <param name="dst">The output disparity map, should have the same size as the input disparity map</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
public void Apply(GpuImage <Gray, Byte> disparity, GpuImage <Gray, Byte> image, GpuImage <Gray, byte> dst, Stream stream)
{
GpuDisparityBilateralFilterApply(_ptr, disparity, image, dst, stream);
}
/// <summary>
/// Transform the image using the lookup table
/// </summary>
/// <typeparam name="TColor">The type of color, should be either 3 channel or 1 channel</typeparam>
/// <param name="image">The image to be transformed</param>
/// <param name="dst">The transformation result</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
public void Transform <TColor>(GpuImage <TColor, byte> image, GpuImage <TColor, byte> dst, Stream stream)
where TColor : struct, IColor
{
GpuInvoke.gpuLookUpTableTransform(_ptr, image, dst, stream);
}
/// <summary>
/// Computes disparity map for the input rectified stereo pair.
/// </summary>
/// <param name="left">The left single-channel, 8-bit image</param>
/// <param name="right">The right image of the same size and the same type</param>
/// <param name="disparity">The disparity map</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
public void FindStereoCorrespondence(GpuImage <Gray, Byte> left, GpuImage <Gray, Byte> right, GpuImage <Gray, Byte> disparity, Stream stream)
{
GpuStereoBMFindStereoCorrespondence(_ptr, left, right, disparity, stream);
}
/// <summary>
/// Computes disparity map for the input rectified stereo pair.
/// </summary>
/// <param name="left">The left single-channel, 8-bit image</param>
/// <param name="right">The right image of the same size and the same type</param>
/// <param name="disparity">The disparity map</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
public void FindStereoCorrespondence(GpuImage <Gray, Byte> left, GpuImage <Gray, Byte> right, GpuImage <Gray, Byte> disparity, Stream stream)
{
GpuInvoke.GpuStereoConstantSpaceBPFindStereoCorrespondence(_ptr, left, right, disparity, stream);
}
/// <summary>
/// This function is similiar to cvCalcBackProjectPatch. It slids through image, compares overlapped patches of size wxh with templ using the specified method and stores the comparison results to result
/// </summary>
/// <param name="image">Image where the search is running. It should be 8-bit or 32-bit floating-point</param>
/// <param name="templ">Searched template; must be not greater than the source image and the same data type as the image</param>
/// <param name="result">A map of comparison results; single-channel 32-bit floating-point. If image is WxH and templ is wxh then result must be W-w+1xH-h+1.</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
public void Match(GpuImage <TColor, TDepth> image, GpuImage <TColor, TDepth> templ, GpuImage <Gray, float> result, Stream stream)
{
if (_ptr == IntPtr.Zero)
{
_ptr = GpuInvoke.gpuTemplateMatchingCreate(image.Type, _method, ref _blockSize);
}
GpuInvoke.gpuTemplateMatchingMatch(_ptr, image, templ, result, stream);
}
public void Apply(GpuImage <TColor, TDepth> image, GpuImage <TColor, TDepth> dst, Stream stream)
{
GpuInvoke.gpuFilterApply(_ptr, image, dst, stream);
}
