/// <summary>
/// Set the SVM detector
/// </summary>
/// <param name="detector">The SVM detector</param>
public void SetSVMDetector(float[] detector)
{
using (VectorOfFloat vec = new VectorOfFloat())
{
vec.Push(detector);
OclInvoke.oclHOGSetSVMDetector(_ptr, vec);
}
}
/// <summary>
/// Returns coefficients of the classifier trained for people detection (for size 64x128).
/// </summary>
/// <returns>The people detector of 64x128 resolution.</returns>
public static float[] GetPeopleDetector64x128()
{
using (VectorOfFloat f = new VectorOfFloat())
{
OclInvoke.oclHOGDescriptorGetPeopleDetector64x128(f);
return(f.ToArray());
}
}
/*
* /// <summary>
* /// Add the model descriptors
* /// </summary>
* /// <param name="modelDescriptors">The model discriptors</param>
* public void Add(Matrix<Byte> modelDescriptors)
* {
* if (!(_distanceType == DistanceType.HammingDist))
* throw new ArgumentException("Hamming distance type requires model descriptor to be Matrix<Byte>");
* gpuBruteForceMatcherAdd(_ptr, modelDescriptors);
* }
*
* /// <summary>
* /// Add the model descriptors
* /// </summary>
* /// <param name="modelDescriptors">The model discriptors</param>
* public void Add(Matrix<float> modelDescriptors)
* {
* if (!(_distanceType == DistanceType.L2 || _distanceType == DistanceType.L1))
* throw new ArgumentException("L1 / L2 distance type requires model descriptor to be Matrix<float>");
* gpuBruteForceMatcherAdd(_ptr, modelDescriptors);
* }*/
/// <summary>
/// Find the k nearest neighbour using the brute force matcher.
/// </summary>
/// <param name="queryDescriptors">The query descriptors</param>
/// <param name="modelDescriptors">The model descriptors</param>
/// <param name="modelIdx">The model index. A n x <paramref name="k"/> matrix where n = <paramref name="queryDescriptors"/>.Cols</param>
/// <param name="distance">The matrix where the distance valus is stored. A n x <paramref name="k"/> matrix where n = <paramref name="queryDescriptors"/>.Size.Height</param>
/// <param name="k">The number of nearest neighbours to be searched</param>
/// <param name="mask">The mask</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 KnnMatchSingle(OclMat <T> queryDescriptors, OclMat <T> modelDescriptors, OclMat <int> modelIdx, OclMat <float> distance, int k, OclMat <Byte> mask)
{
/*
* if (k == 2 && !(modelIdx.IsContinuous && distance.IsContinuous))
* {
* throw new ArgumentException("For k == 2, the allocated index matrix and distance matrix must be continuous");
* }*/
OclInvoke.oclBruteForceMatcherKnnMatchSingle(_ptr, queryDescriptors, modelDescriptors, modelIdx, distance, k, mask);
}
/// <summary>
/// Create an OpenCL SURF detector
/// </summary>
/// <param name="hessianThreshold">The interest operator threshold. Use 100 for default</param>
/// <param name="nOctaves">The number of octaves to process. Use 4 for default</param>
/// <param name="nIntervals">The number of intervals in each octave. Use 4 for default</param>
/// <param name="extended">True, if generate 128-len descriptors, false - 64-len descriptors. Use true for default.</param>
/// <param name="featuresRatio">Max features = featuresRatio * img.size().srea(). Use 0.01 for default</param>
/// <param name="upright">Use false for default. If set to true, the orientation is not computed for the keypoints</param>
public OclSURFDetector(
float hessianThreshold,
int nOctaves,
int nIntervals,
bool extended,
float featuresRatio,
bool upright)
{
_ptr = OclInvoke.oclSURFDetectorCreate(hessianThreshold, nOctaves, nIntervals, extended, featuresRatio, upright);
}
private Rectangle[] DetectMultiScale(
IntPtr image,
double hitThreshold,
Size winStride,
Size padding,
double scale,
int groupThreshold)
{
using (MemStorage storage = new MemStorage())
{
Seq <Rectangle> rectSeq = new Seq <Rectangle>(storage);
OclInvoke.oclHOGDescriptorDetectMultiScale(_ptr, image, rectSeq, hitThreshold, winStride, padding, scale, groupThreshold);
return(rectSeq.ToArray());
}
}
/// <summary>
/// Create a OpenCL cascade classifier using the specific file
/// </summary>
/// <param name="fileName">The file to create the classifier from</param>
public OclCascadeClassifier(String fileName)
: base()
{
#if !NETFX_CORE
FileInfo file = new FileInfo(fileName);
if (!file.Exists)
{
throw new FileNotFoundException("File not found", file.FullName);
}
#endif
_ptr = OclInvoke.oclCascadeClassifierCreate(fileName);
if (_ptr == IntPtr.Zero)
{
throw new NullReferenceException(String.Format("Fail to create OpenCL HaarCascade object: {0}", fileName));
}
}
/// <summary>
/// Create a new HOGDescriptor using the specific parameters
/// </summary>
/// <param name="blockSize">Block size in cells. Use (16, 16) for default.</param>
/// <param name="cellSize">Cell size. Use (8, 8) for default.</param>
/// <param name="blockStride">Block stride. Must be a multiple of cell size. Use (8,8) for default.</param>
/// <param name="gammaCorrection">Do gamma correction preprocessing or not. Use true for default.</param>
/// <param name="L2HysThreshold">L2-Hys normalization method shrinkage. Use 0.2 for default.</param>
/// <param name="nbins">Number of bins. Use 9 bins per cell for deafault.</param>
/// <param name="nLevels">Maximum number of detection window increases. Use 64 for default</param>
/// <param name="winSigma">Gaussian smoothing window parameter. Use -1 for default.</param>
/// <param name="winSize">Detection window size. Must be aligned to block size and block stride. Must match the size of the training image. Use (64, 128) for default.</param>
public OclHOGDescriptor(
Size winSize,
Size blockSize,
Size blockStride,
Size cellSize,
int nbins,
double winSigma,
double L2HysThreshold,
bool gammaCorrection,
int nLevels)
{
_ptr = OclInvoke.oclHOGDescriptorCreate(
ref winSize,
ref blockSize,
ref blockStride,
ref cellSize,
nbins,
winSigma,
L2HysThreshold,
gammaCorrection,
nLevels);
}
/// <summary>
/// Obtain the keypoints array from OclMat
/// </summary>
/// <param name="src">The keypoints obtained from DetectKeyPointsRaw</param>
/// <param name="dst">The vector of keypoints</param>
public void DownloadKeypoints(OclMat <float> src, VectorOfKeyPoint dst)
{
OclInvoke.oclSURFDownloadKeypoints(_ptr, src, dst);
}
/// <summary>
/// Release the unmanaged memory associated with this OclMat
/// </summary>
protected override void DisposeObject()
{
OclInvoke.OclMatRelease(ref _ptr);
}
/// <summary>
/// Create an empty OclMat
/// </summary>
public OclMat()
: this(OclInvoke.OclMatCreateDefault())
{
}
/// <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>
public void FindStereoCorrespondence(OclImage <Gray, Byte> left, OclImage <Gray, Byte> right, OclImage <Gray, Byte> disparity)
{
OclInvoke.oclStereoConstantSpaceBPFindStereoCorrespondence(_ptr, left, right, disparity);
}
/// <summary>
/// Release the standard vector
/// </summary>
protected override void DisposeObject()
{
OclInvoke.VectorOfOclInfoRelease(_ptr);
}
/// <summary>
/// Create an standard vector of OclInfo of the specific size
/// </summary>
/// <param name="size">The size of the vector</param>
public VectorOfOclInfo(int size)
{
_ptr = OclInvoke.VectorOfOclInfoCreateSize(size);
}
/// <summary>
/// Release all the unmanaged memory associated with this optical flow solver.
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclOpticalFlowDualTVL1Release(ref _ptr);
}
/// <summary>
/// Create the Dual TV L1 optical flow solver
/// </summary>
public OclOpticalFlowDual_TVL1()
{
_ptr = OclInvoke.oclOpticalFlowDualTVL1Create();
}
/// <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>(OclImage <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 (OclImage <TSrcColor, TSrcDepth> tmp = srcImage.Resize(Size, Emgu.CV.CvEnum.INTER.CV_INTER_LINEAR))
{
ConvertFrom(tmp);
return;
}
}
if (typeof(TColor) == typeof(TSrcColor))
{
#region same color
if (typeof(TDepth) == typeof(TSrcDepth)) //same depth
{
OclInvoke.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;
}
OclInvoke.ConvertTo(srcImage.Ptr, Ptr, scale, shift);
}
else
{
OclInvoke.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);
}
else
{ //different depth
using (OclImage <TSrcColor, TDepth> tmp = srcImage.Convert <TSrcColor, TDepth>()) //convert depth
ConvertColor(tmp.Ptr, Ptr, typeof(TSrcColor), typeof(TColor), Size);
}
#endregion
}
}
/// <summary>
/// Create a new HOGDescriptor
/// </summary>
public OclHOGDescriptor()
{
_ptr = OclInvoke.oclHOGDescriptorCreateDefault();
}
/// <summary>
/// Release the unmanaged memory associated with this HOGDescriptor
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclHOGDescriptorRelease(ref _ptr);
}
/// <summary>
/// Release all the unmanaged memory associated with this matcher
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclBruteForceMatcherRelease(ref _ptr);
}
/// <summary>
/// Create a OclMatchTemplateBuf
/// </summary>
public OclMatchTemplateBuf()
{
_ptr = OclInvoke.oclMatchTemplateBufCreate();
}
/// <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(OclImage <Gray, byte> frame0, OclImage <Gray, byte> frame1, OclImage <Gray, float> u, OclImage <Gray, float> v)
{
OclInvoke.oclOpticalFlowDualTVL1Compute(_ptr, frame0, frame1, u, v);
}
/// <summary>
/// Release the buffer
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclMatchTemplateBufRelease(ref _ptr);
}
/// <summary>
/// Create an empty standard vector of OclInfo
/// </summary>
public VectorOfOclInfo()
{
_ptr = OclInvoke.VectorOfOclInfoCreate();
}
/// <summary>
/// Create a stereoBM
/// </summary>
/// <param name="preset">Preset type</param>
/// <param name="numberOfDisparities">The number of disparities. Must be multiple of 8. Use 64 for default </param>
/// <param name="winSize">The SAD window size. Use 19 for default</param>
public OclStereoBM(PresetType preset, int numberOfDisparities, int winSize)
{
_ptr = OclInvoke.oclStereoBMCreate(preset, numberOfDisparities, winSize);
}
/// <summary>
/// Clear the vector
/// </summary>
public void Clear()
{
OclInvoke.VectorOfOclInfoClear(_ptr);
}
/// <summary>
/// Release the stereo state and all the memory associate with it
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclStereoBMRelease(ref _ptr);
}
/// <summary>
/// A Constant-Space Belief Propagation Algorithm for Stereo Matching
/// </summary>
/// <param name="ndisp">The number of disparities. Use 128 as default</param>
/// <param name="iters">The number of BP iterations on each level. Use 8 as default.</param>
/// <param name="levels">The number of levels. Use 4 as default</param>
/// <param name="nrPlane">The number of active disparity on the first level. Use 4 as default.</param>
public OclStereoConstantSpaceBP(int ndisp, int iters, int levels, int nrPlane)
{
_ptr = OclInvoke.oclStereoConstantSpaceBPCreate(ndisp, iters, levels, nrPlane);
}
/// <summary>
/// Obtain an OclMat from the keypoints array
/// </summary>
/// <param name="src">The keypoints array</param>
/// <param name="dst">An OclMat that represent the keypoints</param>
public void UploadKeypoints(VectorOfKeyPoint src, OclMat <float> dst)
{
OclInvoke.oclSURFUploadKeypoints(_ptr, src, dst);
}
/// <summary>
/// Release the unmanaged memory
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclStereoConstantSpaceBPRelease(ref _ptr);
}
/// <summary>
/// Release the unmanaged resource associate to the Detector
/// </summary>
protected override void DisposeObject()
{
OclInvoke.oclSURFDetectorRelease(ref _ptr);
}