/*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:    cvCanny
 //    Purpose: Canny edge detection
 //    Context:
 //    Parameters:
 //      src - source byte-depth, single channel image,
 //      dst - destination byte-depth, single channel image with edges,
 //      apertureSize - size of Sobel operator aperture,
 //      lowThreshold,
 //      highThreshold - tresholds, applied in hysteresis thresholding
 //    Returns:
 //    Notes: image gradient magnitude has scale factor 2^(2*apertureSize-3)
 //           so user must choose appropriate lowThreshold and highThreshold
 //           i.e. if real gradient magnitude is 1, then 3x3 Sobel used in this function
 //           will output 8 for apertureSize == 3.
 //F*/
 OPENCVAPI  void  cvCanny( const CvArr* src, CvArr* dst, double lowThreshold,
                           double highThreshold, int  apertureSize CV_DEFAULT(3) );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:     cvPreCornerDetect
 //    Purpose:  Calculating constraint image for corner detection
 //              Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy
 //    Context:
 //    Parameters:
 //      src - source image
 //      dst - destination feature image
 //      apertureSize - Sobel operator aperture size
 //    Returns:
 //F*/
 OPENCVAPI void cvPreCornerDetect( const CvArr* src, CvArr* dst,
                                   int apertureSize CV_DEFAULT(3) );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:    cvCalcCornerEigenValsAndVecs
 //    Purpose:  Calculates eigen values and vectors of 2x2
 //              gradient matrix at every image pixel
 //    Context:
 //    Parameters:
 //      src      - pointer to the source image
 //      eigenvv  - destination image, containing two eigen values and
 //                 components of two eigen vectors for each raster point
 //               ( i.e., this image is 6 times wider than source image )
 //      apertureSize - Sobel operator aperture size
 //      blockSize  - size of block for summation(averaging block)
 //    Returns:
 //F*/
 OPENCVAPI void  cvCornerEigenValsAndVecs( const CvArr* src, CvArr* eigenvv,
                                           int blockSize,
                                           int apertureSize CV_DEFAULT(3) );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:    cvCornerMinEigenVal
 //    Purpose:  Calculates minimal eigenvalue for 2x2 gradient matrix at
 //              every image pixel
 //    Context:
 //    Parameters:
 //      src        - source image
 //      eigenval   - minimal eigen value for each point of the source image
 //      apertureSize - Sobel operator aperture size
 //      blockSize  - size of block for summation(averaging block)
 //    Returns:
 //F*/
 OPENCVAPI void  cvCornerMinEigenVal( const CvArr* src, CvArr* eigenval,
                                      int blockSize, int apertureSize CV_DEFAULT(3) );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:    cvFindCornerSubPix
 //    Purpose:
 //      Finds corners on the image with sub-pixel accuracy given
 //      initial guesses for those corners.
 //    Context:
 //    Parameters:
 //      src        - source image
 //      corners    - initial coordinates of corners on input, adjusted coordinates
 //                   on output
 //      count      - number of corner points
 //      win        - search window size for each corner.
 //                   actually, for each corner(x,y), the window
 //                  (x - win.width .. x + win.width,y - win.height .. y + win_height)
 //                   is used.(window  moves with the point after every iteration)
 //      zeroZone   - size of zero zone in the middle of the mask.
 //      criteria   - This parameter specifies, how many times iterate and what precision
 //                   is required.
 //    Returns:
 //      Nothing
 //    Notes:
 //      Size of destination ROI is not passed into the function, because
 //      it assumes dst ROI size:
 //      =(src_size.width - 2, src_size.height - 2) if both kernels are used
 //      =(src_size.width - 2, src_size.height)     if horizontal kernel != 0 only.
 //      =(src_size.width, src_size.height - 2)     if vertical kernel != 0 only.
 F*/
 OPENCVAPI  void  cvFindCornerSubPix( const CvArr* src,CvPoint2D32f*  corners,
                                      int count, CvSize win,CvSize zeroZone,
                                      CvTermCriteria  criteria );

 /*F///////////////////////////////////////////////////////////////////////////////////////
 //    Name:    cvGoodFeaturesToTrack
 //    Purpose:
 //      Finds strong corners on the image
 //    Context:
 //    Parameters:
 //      image    - input image(IPL_DEPTH_8U,IPL_DEPTH_8S or IPL_DEPTH_32F,single channel)
 //      eigImage - temporary image(IPL_DEPTH_32F,single channel),
 //                 which will contain minimal eigen value for each point
 //      tempImage- temporary image(IPL_DEPTH_32F,single channel),
 //                 which is used in non-maxima suppression.
 //      corners  - output corners
 //      corner_count - number of output corners
 //      quality_level - only those corners are selected, which minimal eigen value is
 //                      non-less than maximum of minimal eigen values on the image,
 //                      multiplied by quality_level. For example, quality_level = 0.1
 //                      means that selected corners must be at least 1/10 as good as
 //                      the best corner.
 //      min_distance - The selected corners(after thresholding using quality_level)
 //                     are rerified such that pair-wise distance between them is
 //                     non-less than min_distance
 //      block_size- Size of the averaging block, passed to underlying cvCornerMinEigenVal
 //                  or cvCornerHarris used by the function.
 //      use_harris- If nonzero, Harris operator (cvCornerHarris) is used instead of 
 //                  default cvCornerMinEigenVal.
 //      k         - Free parameter of Harris detector; used only if use_harris¡â0 
 //
 //    Returns:
 F*/
 OPENCVAPI void  cvGoodFeaturesToTrack( const CvArr* image, CvArr* eigImage,
                                        CvArr* tempImage, CvPoint2D32f* corners,
                                        int* corner_count, double  quality_level,
                                        double  min_distance, const CvArr* mask=NULL,
                                        int block_size=3, int use_harris=0, 
                                        double k=0.04);