Documentation updates.

Emgu.CV.Contrib/LineDescriptor/LSDDetector.cs

@@ -12,20 +12,37 @@ using Emgu.CV.Util;
 using Emgu.Util;
 using System.Diagnostics;
 
-
 namespace Emgu.CV.LineDescriptor
 {
+   /// <summary>
+   /// The lines extraction methodology described in the following is mainly based on: R Grompone Von Gioi, Jeremie Jakubowicz, Jean-Michel Morel, and Gregory Randall. Lsd: A fast line segment detector with a false detection control. IEEE Transactions on Pattern Analysis and Machine Intelligence, 32(4):722–732, 2010.
+   /// </summary>
    public class LSDDetector : UnmanagedObject
    {
+      /// <summary>
+      /// Default constructor
+      /// </summary>
       public LSDDetector()
       {
          _ptr = LineDescriptorInvoke.cveLineDescriptorLSDDetectorCreate();
       }
 
+      /// <summary>
+      /// Detect lines inside an image.
+      /// </summary>
+      /// <param name="image">	input image</param>
+      /// <param name="keylines">vector that will store extracted lines for one or more images</param>
+      /// <param name="scale">scale factor used in pyramids generation</param>
+      /// <param name="numOctaves">number of octaves inside pyramid</param>
+      /// <param name="mask">	mask matrix to detect only KeyLines of interest</param>
       public void Detect(Mat image, VectorOfKeyLine keylines, int scale, int numOctaves, Mat mask = null)
       {
          LineDescriptorInvoke.cveLineDescriptorLSDDetectorDetect(_ptr, image, keylines, scale, numOctaves, mask);
       }
+
+      /// <summary>
+      /// Release the unmanaged memory associated with this object.
+      /// </summary>
       protected override void DisposeObject()
       {
          if (_ptr != IntPtr.Zero)

Emgu.CV.Cuda/CudaCascadeClassifier.cs

@@ -39,10 +39,11 @@ namespace Emgu.CV.Cuda
       }
 
       /// <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.
+      /// Detects objects of different sizes in the input image.
       /// </summary>
-      /// <param name="image">The image where search will take place</param>
-      /// <returns>An array of regions for the detected objects</returns>
+      /// <param name="image">Matrix of type CV_8U containing an image where objects should be detected.</param>
+      /// <param name="objects">Buffer to store detected objects (rectangles).</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 DetectMultiScale(IInputArray image, IOutputArray objects, Stream stream = null)
       {
          using (InputArray iaImage = image.GetInputArray())
@@ -51,6 +52,11 @@ namespace Emgu.CV.Cuda
                stream == null ? IntPtr.Zero : stream.Ptr);
       }
 
+      /// <summary>
+      /// Converts objects array from internal representation to standard vector.
+      /// </summary>
+      /// <param name="objects">Objects array in internal representation.</param>
+      /// <returns>Resulting array.</returns>
       public Rectangle[] Convert(IOutputArray objects)
       {
          using (OutputArray oaObjects = objects.GetOutputArray())
@@ -71,6 +77,9 @@ namespace Emgu.CV.Cuda
             _buffer.Dispose();
       }
 
+      /// <summary>
+      /// Parameter specifying how much the image size is reduced at each image scale.
+      /// </summary>
       public double ScaleFactor
       {
          get { return CudaInvoke.cudaCascadeClassifierGetScaleFactor(_ptr); }
@@ -80,12 +89,18 @@ namespace Emgu.CV.Cuda
          }
       }
 
+      /// <summary>
+      /// Parameter specifying how many neighbors each candidate rectangle should have to retain it.
+      /// </summary>
       public int MinNeighbors
       {
          get { return CudaInvoke.cudaCascadeClassifierGetMinNeighbors(_ptr); }
          set {  CudaInvoke.cudaCascadeClassifierSetMinNeighbors(_ptr, value);}
       }
 
+      /// <summary>
+      /// Minimum possible object size. Objects smaller than that are ignored.
+      /// </summary>
       public Size MinObjectSize
       {
          get

Emgu.CV.Cuda/CudaHOGDescriptor.cs

@@ -91,6 +91,12 @@ namespace Emgu.CV.Cuda
          }
       }*/
 
+      /// <summary>
+      /// Performs object detection with a multi-scale window.
+      /// </summary>
+      /// <param name="image">Source image.</param>
+      /// <param name="objects">Detected objects boundaries.</param>
+      /// <param name="confident">Optional output array for confidences.</param>
       public void DetectMultiScale(IInputArray image, VectorOfRect objects, VectorOfDouble confident = null)
       {
          using (InputArray iaImage = image.GetInputArray())
@@ -107,18 +113,27 @@ namespace Emgu.CV.Cuda
          CudaInvoke.cudaHOGRelease(ref _ptr);
       }
 
+      /// <summary>
+      /// Gaussian smoothing window parameter.
+      /// </summary>
       public double WinSigma
       {
          get { return CudaInvoke.cudaHOGGetWinSigma(_ptr); }
          set { CudaInvoke.cudaHOGSetWinSigma(_ptr, value); }
       }
 
+      /// <summary>
+      /// Maximum number of detection window increases.
+      /// </summary>
       public int NumLevels
       {
          get { return CudaInvoke.cudaHOGGetNumLevels(_ptr); }
          set { CudaInvoke.cudaHOGSetNumLevels(_ptr, value);}
       }
 
+      /// <summary>
+      /// Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See groupRectangles.
+      /// </summary>
       public int GroupThreshold
       {
          get { return CudaInvoke.cudaHOGGetGroupThreshold(_ptr); }
@@ -128,18 +143,27 @@ namespace Emgu.CV.Cuda
          }
       }
 
+      /// <summary>
+      /// 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.
+      /// </summary>
       public double HitThreshold
       {
          get { return CudaInvoke.cudaHOGGetHitThreshold(_ptr); }
          set { CudaInvoke.cudaHOGSetHitThreshold(_ptr, value);}
       }
 
+      /// <summary>
+      /// Coefficient of the detection window increase.
+      /// </summary>
       public double ScaleFactor
       {
          get { return CudaInvoke.cudaHOGGetScaleFactor(_ptr); }
          set {  CudaInvoke.cudaHOGSetScaleFactor(_ptr, value);}
       }
 
+      /// <summary>
+      /// Flag to specify whether the gamma correction preprocessing is required or not.
+      /// </summary>
       public bool GammaCorrection
       {
          get { return CudaInvoke.cudaHOGGetGammaCorrection(_ptr); }

Emgu.CV.Cuda/CudaInvoke.cs

@@ -352,6 +352,12 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern void cudaSqrt(IntPtr src, IntPtr dst, IntPtr stream);
 
+      /// <summary>
+      /// Transposes a matrix.
+      /// </summary>
+      /// <param name="src">Source matrix. 1-, 4-, 8-byte element sizes are supported for now.</param>
+      /// <param name="dst">Destination matrix.</param>
+      /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
       public static void Transpose(IInputArray src, IOutputArray dst, Stream stream = null)
       {
          using (InputArray iaSrc = src.GetInputArray())
@@ -388,6 +394,9 @@ namespace Emgu.CV.Cuda
       /// <param name="dst">The destination image.</param>
       /// <param name="interpolation">The interpolation type. Supports INTER_NEAREST, INTER_LINEAR.</param>
       /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
+      /// <param name="fx">Scale factor along the horizontal axis. If it is zero, it is computed as: (double)dsize.width/src.cols</param>
+      /// <param name="fy">Scale factor along the vertical axis. If it is zero, it is computed as: (double)dsize.height/src.rows</param>
+      /// <param name="dsize">Destination image size. If it is zero, it is computed as: dsize = Size(round(fx* src.cols), round(fy* src.rows)). Either dsize or both fx and fy must be non-zero.</param>
       public static void Resize(IInputArray src, IOutputArray dst, Size dsize, double fx = 0, double fy = 0, CvEnum.Inter interpolation = Inter.Linear, Stream stream = null)
       {
          using (InputArray iaSrc = src.GetInputArray())
@@ -692,6 +701,14 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern double cudaNorm1(IntPtr src1, Emgu.CV.CvEnum.NormType normType, IntPtr mask);
 
+      /// <summary>
+      /// Returns the norm of a matrix.
+      /// </summary>
+      /// <param name="src">Source matrix. Any matrices except 64F are supported.</param>
+      /// <param name="dst">The GpuMat to store the result</param>
+      /// <param name="normType">Norm type. NORM_L1 , NORM_L2 , and NORM_INF are supported for now.</param>
+      /// <param name="mask">optional operation mask; it must have the same size as src1 and CV_8UC1 type.</param>
+      /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
       public static void CalcNorm(IInputArray src, IOutputArray dst, NormType normType = NormType.L2, IInputArray mask = null,
          Stream stream = null)
       {
@@ -703,6 +720,14 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern void cudaCalcNorm(IntPtr src, IntPtr dst, NormType normType, IntPtr mask, IntPtr stream);
 
+      /// <summary>
+      /// Returns the difference of two matrices.
+      /// </summary>
+      /// <param name="src1">Source matrix. Any matrices except 64F are supported.</param>
+      /// <param name="src2">Second source matrix (if any) with the same size and type as src1.</param>
+      /// <param name="dst">The GpuMat where the result will be stored in</param>
+      /// <param name="normType">Norm type. NORM_L1 , NORM_L2 , and NORM_INF are supported for now.</param>
+      /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
       public static void CalcNormDiff(IInputArray src1, IInputArray src2, IOutputArray dst, NormType normType = NormType.L2,
          Stream stream = null)
       {
@@ -714,7 +739,12 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern void cudaCalcNormDiff(IntPtr src1, IntPtr src2, IntPtr dst, NormType normType, IntPtr stream);
 
-
+      /// <summary>
+      /// Returns the sum of absolute values for matrix elements.
+      /// </summary>
+      /// <param name="src">Source image of any depth except for CV_64F.</param>
+      /// <param name="mask">optional operation mask; it must have the same size as src and CV_8UC1 type.</param>
+      /// <returns>The sum of absolute values for matrix elements.</returns>
       public static MCvScalar AbsSum(IInputArray src, IInputArray mask = null)
       {
          MCvScalar result = new MCvScalar();
@@ -726,6 +756,13 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern void cudaAbsSum(IntPtr src, ref MCvScalar sum, IntPtr mask);
 
+      /// <summary>
+      /// Returns the sum of absolute values for matrix elements.
+      /// </summary>
+      /// <param name="src">Source image of any depth except for CV_64F.</param>
+      /// <param name="dst">The GpuMat where the result will be stored.</param>
+      /// <param name="mask">optional operation mask; it must have the same size as src1 and CV_8UC1 type.</param>
+      /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
       public static void CalcAbsSum(IInputArray src, IOutputArray dst, IInputArray mask = null, Stream stream = null)
       {
          using (InputArray iaSrc = src.GetInputArray())
@@ -736,6 +773,12 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern void cudaCalcAbsSum(IntPtr src, IntPtr dst, IntPtr mask, IntPtr stream);
 
+      /// <summary>
+      /// Returns the squared sum of matrix elements.
+      /// </summary>
+      /// <param name="src">Source image of any depth except for CV_64F.</param>
+      /// <param name="mask">optional operation mask; it must have the same size as src1 and CV_8UC1 type.</param>
+      /// <returns>The squared sum of matrix elements.</returns>
       public static MCvScalar SqrSum(IInputArray src, IInputArray mask = null)
       {
          MCvScalar result = new MCvScalar();
@@ -747,6 +790,13 @@ namespace Emgu.CV.Cuda
       [DllImport(CvInvoke.ExternCudaLibrary, CallingConvention = CvInvoke.CvCallingConvention)]
       private static extern void cudaSqrSum(IntPtr src, ref MCvScalar sqrSum, IntPtr mask);
 
+      /// <summary>
+      /// Returns the squared sum of matrix elements.
+      /// </summary>
+      /// <param name="src">Source image of any depth except for CV_64F.</param>
+      /// <param name="dst">The GpuMat where the result will be stored</param>
+      /// <param name="mask">optional operation mask; it must have the same size as src1 and CV_8UC1 type.</param>
+      /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
       public static void CalcSqrSum(IInputArray src, IOutputArray dst, IInputArray mask = null, Stream stream = null)
       {
          using (InputArray iaSrc = src.GetInputArray())
@@ -1053,6 +1103,7 @@ namespace Emgu.CV.Cuda
       /// <param name="borderMode">The border mode, use BORDER_TYPE.CONSTANT for default.</param>
       /// <param name="borderValue">The border value, use new MCvScalar() for default.</param>
       /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
+      /// <param name="dSize">The size of the destination image</param>
       public static void WarpAffine(IInputArray src, IOutputArray dst, IInputArray M, Size dSize, CvEnum.Inter flags = Inter.Linear, CvEnum.BorderType borderMode = BorderType.Constant, MCvScalar borderValue = new MCvScalar(), Stream stream = null)
       {
          using (InputArray iaSrc = src.GetInputArray())
@@ -1073,6 +1124,7 @@ namespace Emgu.CV.Cuda
       /// <param name="borderMode">The border mode, use BORDER_TYPE.CONSTANT for default.</param>
       /// <param name="borderValue">The border value, use new MCvScalar() for default.</param>
       /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
+      /// <param name="dSize">The size of the destination image</param>
       public static void WarpPerspective(IInputArray src, IOutputArray dst, IInputArray M, Size dSize, CvEnum.Inter flags = Inter.Linear, CvEnum.BorderType borderMode = BorderType.Constant, MCvScalar borderValue = new MCvScalar(), Stream stream = null)
       {
          using (InputArray iaSrc = src.GetInputArray())
@@ -1113,6 +1165,7 @@ namespace Emgu.CV.Cuda
       /// <param name="angle">Angle of rotation in degrees</param>
       /// <param name="xShift">Shift along the horizontal axis</param>
       /// <param name="yShift">Shift along the verticle axis</param>
+      /// <param name="dSize">The size of the destination image</param>
       /// <param name="interpolation">Interpolation method. Only INTER_NEAREST, INTER_LINEAR, and INTER_CUBIC are supported.</param>
       /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
       public static void Rotate(IInputArray src, IOutputArray dst, Size dSize, double angle, double xShift = 0, double yShift = 0, CvEnum.Inter interpolation = Inter.Linear, Stream stream = null)
@@ -1190,6 +1243,7 @@ namespace Emgu.CV.Cuda
       /// </summary>
       /// <param name="src">The source GpuMat</param>
       /// <param name="dst">The resulting GpuMat of the DST, must be pre-allocated and continious. If single channel, the result is real. If double channel, the result is complex</param>
+      /// <param name="dftSize">Size of a discrete Fourier transform.</param>
       /// <param name="flags">DFT flags</param>
       /// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>  
       public static void Dft(IInputArray src, IOutputArray dst, Size dftSize, CvEnum.DxtType flags = DxtType.Forward, Stream stream = null)
@@ -1202,7 +1256,7 @@ namespace Emgu.CV.Cuda
       private static extern void cudaDft(IntPtr src, IntPtr dst, ref Size dftSize, CvEnum.DxtType flags, IntPtr stream);
 
       /// <summary>
-      /// 
+      /// Performs a per-element multiplication of two Fourier spectrums and scales the result.
       /// </summary>
       /// <param name="src1">First spectrum.</param>
       /// <param name="src2">Second spectrum with the same size and type.</param>

Emgu.CV.Cuda/Filters/CudaBoxMaxFilter.cs

@@ -27,6 +27,8 @@ namespace Emgu.CV.Cuda
       /// <param name="anchor">The center of the kernel. User (-1, -1) for the default kernel center.</param>
       /// <param name="borderType">The border type.</param>
       /// <param name="borderValue">The border value.</param>
+      /// <param name="srcDepth">The depth type of the source image</param>
+      /// <param name="srcChannels">The number of channels of the source image</param>
       public CudaBoxMaxFilter(DepthType srcDepth, int srcChannels, Size ksize, Point anchor, CvEnum.BorderType borderType = BorderType.Default, MCvScalar borderValue = new MCvScalar())
       {
          _ptr = CudaInvoke.cudaCreateBoxMaxFilter(CvInvoke.MakeType(srcDepth, srcChannels), ref ksize, ref anchor, borderType, ref borderValue);

Emgu.CV.Cuda/GpuMat.cs

@@ -59,6 +59,13 @@ namespace Emgu.CV.Cuda
             Create(rows, cols, depthType, channels);
       }
 
+      /// <summary>
+      /// allocates new GpuMat data unless the GpuMat already has specified size and type
+      /// </summary>
+      /// <param name="rows">The number of rows</param>
+      /// <param name="cols">The number of cols</param>
+      /// <param name="depthType">The depth type</param>
+      /// <param name="channels">The number of channels.</param>
       public void Create(int rows, int cols, DepthType depthType, int channels)
       {
          CudaInvoke.gpuMatCreate(Ptr, rows, cols, CvInvoke.MakeType(depthType, channels));
@@ -641,6 +648,7 @@ namespace Emgu.CV.Cuda
       /// Create a GpuMat from the unmanaged pointer
       /// </summary>
       /// <param name="ptr">The unmanaged pointer to the GpuMat</param>
+      /// <param name="needDispose""></param>
       internal GpuMat(IntPtr ptr, bool needDispose)
          : base(ptr, needDispose)
       {

Emgu.CV.Extern/core/umat_c.cpp

@@ -73,7 +73,7 @@ cv::Mat* cveUMatGetMat(cv::UMat* mat, int access)
    return result;
 }
 
-void cveUMatConvertTo(  cv::UMat* mat, cv::_OutputArray* out, int rtype, double alpha, double beta )
+void cveUMatConvertTo(cv::UMat* mat, cv::_OutputArray* out, int rtype, double alpha, double beta )
 {
    mat->convertTo(*out, rtype, alpha, beta);
 }
@@ -88,14 +88,14 @@ cv::UMat* cveUMatReshape(cv::UMat* mat, int cn, int rows)
 
 void cveUMatCopyDataTo(cv::UMat* mat, unsigned char* dest)
 {
-   const int* sizes = mat->size;
+   //const int* sizes = mat->size;
    cv::Mat destMat = cv::Mat(mat->dims, mat->size, mat->type(), dest);
    mat->copyTo(destMat);
 }
 
 void cveUMatCopyDataFrom(cv::UMat* mat, unsigned char* source)
 {
-   const int* sizes = mat->size;
+   //const int* sizes = mat->size;
    cv::Mat fromMat = cv::Mat(mat->dims, mat->size, mat->type(), source);
    fromMat.copyTo(*mat);
 }

Emgu.CV/Ocl/Kernel.cs

@@ -134,6 +134,14 @@ namespace Emgu.CV.Ocl
          return OclInvoke.oclKernelSet(_ptr, i, data, size);
       }
 
+      /// <summary>
+      /// Execute the kernel
+      /// </summary>
+      /// <param name="globalsize">The global size</param>
+      /// <param name="localsize">The local size</param>
+      /// <param name="sync">If true, the code is run synchronously (blocking)</param>
+      /// <param name="q">Optional Opencl queue</param>
+      /// <returns>True if the execution is sucessful</returns>
       public bool Run(IntPtr[] globalsize, IntPtr[] localsize, bool sync, Queue q = null)
       {
          Debug.Assert(localsize == null || globalsize.Length == localsize.Length, "The dimension of global size do not match the dimension of local size.");

Emgu.CV/Ocl/KernelArg.cs

@@ -11,8 +11,11 @@ using System.Runtime.InteropServices;
 
 namespace Emgu.CV.Ocl
 {
-    public class KernelArg : UnmanagedObject
-    {
+   /// <summary>
+   /// OpenCL kernel arg
+   /// </summary>
+   public class KernelArg : UnmanagedObject
+   {
       /// <summary>
       /// KernelArg flags
       /// </summary>
@@ -49,17 +52,29 @@ namespace Emgu.CV.Ocl
          NoSize = 256
       }
 
-       public KernelArg(Flags flags, UMat m, int wscale = 1, int iwscale = 1, IntPtr obj = new IntPtr(), IntPtr sz = new IntPtr())
-       {
-          _ptr = OclInvoke.oclKernelArgCreate(flags, m, wscale, iwscale, obj, sz);
-       }
+      /// <summary>
+      /// Create the OCL kernel arg
+      /// </summary>
+      /// <param name="flags">The flags</param>
+      /// <param name="m">The UMat</param>
+      /// <param name="wscale">wscale</param>
+      /// <param name="iwscale">iwscale</param>
+      /// <param name="obj">obj</param>
+      /// <param name="sz">sz</param>
+      public KernelArg(Flags flags, UMat m, int wscale = 1, int iwscale = 1, IntPtr obj = new IntPtr(), IntPtr sz = new IntPtr())
+      {
+         _ptr = OclInvoke.oclKernelArgCreate(flags, m, wscale, iwscale, obj, sz);
+      }
 
-       protected override void DisposeObject()
-       {
+      /// <summary>
+      /// Release the unmanaged memory associated with this object
+      /// </summary>
+      protected override void DisposeObject()
+      {
          if (_ptr != IntPtr.Zero)
             OclInvoke.oclKernelArgRelease(ref _ptr);
-       }
-    }
+      }
+   }
 
    /// <summary>
    /// Class that contains ocl functions.

Emgu.CV/Ocl/ProgramSource.cs

@@ -11,9 +11,17 @@ using System.Runtime.InteropServices;
 
 namespace Emgu.CV.Ocl
 {
+   /// <summary>
+   /// Open CL kernel program source code
+   /// </summary>
    public class ProgramSource : UnmanagedObject
    {
       private CvString _programSource;
+
+      /// <summary>
+      /// Create OpenCL program source code
+      /// </summary>
+      /// <param name="source">The source code</param>
       public ProgramSource(String source)
       {
          _programSource = new CvString(source);
@@ -21,6 +29,9 @@ namespace Emgu.CV.Ocl
          
       }
 
+      /// <summary>
+      /// Get the source code as String
+      /// </summary>
       public String Source
       {
          get
@@ -29,7 +40,10 @@ namespace Emgu.CV.Ocl
                return s.ToString();
          }
       }
-
+      
+      /// <summary>
+      /// Release the unmanaged memory associated with this object
+      /// </summary>
       protected override void DisposeObject()
       {
          OclInvoke.oclProgramSourceRelease(ref _ptr);

Emgu.CV/Ocl/Queue.cs

@@ -11,18 +11,30 @@ using System.Runtime.InteropServices;
 
 namespace Emgu.CV.Ocl
 {
+   /// <summary>
+   /// An OpenCL Queue
+   /// </summary>
    public class Queue : UnmanagedObject
    {
+      /// <summary>
+      /// OpenCL queue
+      /// </summary>
       public Queue()
       {
          _ptr = OclInvoke.oclQueueCreate();
       }
 
+      /// <summary>
+      /// Wait for the queue to finish
+      /// </summary>
       public void Finish()
       {
          OclInvoke.oclQueueFinish(_ptr);
       }
 
+      /// <summary>
+      /// Release the unmanaged memory associated with this object.
+      /// </summary>
       protected override void DisposeObject()
       {
          if (_ptr != IntPtr.Zero)

Emgu.CV/Util/InputArray.cs

@@ -196,6 +196,11 @@ namespace Emgu.CV
          return CvInvoke.cveInputArrayGetDepth(_ptr, idx);
       }
 
+      /// <summary>
+      /// Get the number of dimensions
+      /// </summary>
+      /// <param name="i">The optional index</param>
+      /// <returns>The dimensions</returns>
       public int GetDims(int i = -1)
       {
          return CvInvoke.cveInputArrayGetDims(_ptr, i);
@@ -213,6 +218,11 @@ namespace Emgu.CV
          return CvInvoke.cveInputArrayGetChannels(_ptr, idx);
       }
 
+      /// <summary>
+      /// Copy this Input array to another.
+      /// </summary>
+      /// <param name="arr">The destination array.</param>
+      /// <param name="mask">The optional mask.</param>
       public void CopyTo(IOutputArray arr, IInputArray mask = null)
       {
          using (OutputArray oaArr = arr.GetOutputArray())