Changeset 31948

Timestamp:

04/05/09 23:34:21 (4 years ago)

Author:

schima

Message:

cvHoughCircles

Location:

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp

Files:

• Class/CvHuMoments.cs (modified) (2 diffs)
• Class/CvMoments.cs (modified) (2 diffs)
• Core/CvDll.cs (modified) (1 diff)
• Core/Cv_D-H.cs (modified) (6 diffs)
• OpenCvSharp.csproj (modified) (2 diffs)
• Struct/CvCircleSegment.cs (added)
• Struct/CvLineSegmentPoint.cs (modified) (2 diffs)
• Struct/CvLineSegmentPolar.cs (modified) (2 diffs)

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Class/CvHuMoments.cs

@@ -10 +10 @@
 {
     /// <summary>
-    /// 
+    /// Hu moments
     /// </summary>
     [Serializable]
@@ -33 +33 @@
 #else
         /// <summary>
-        /// 
+        /// Initialize by cvGetHuMoments
         /// </summary>
-        /// <param name="moments"></param>
+        /// <param name="moments">Pointer to the moment state structure. </param>
 #endif
         public CvHuMoments(CvMoments moments)

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Class/CvMoments.cs

@@ -10 +10 @@
 {
     /// <summary>
-    /// 
+    /// Moment state structure 
     /// </summary>
     [Serializable]
@@ -38 +38 @@
 #else
         /// <summary>
-        /// 
+        /// Initialize by cvMoments
         /// </summary>
-        /// <param name="arr"></param>
-        /// <param name="binary"></param>
+        /// <param name="arr">Image (1-channel or 3-channel with COI set) or polygon (CvSeq of points or a vector of points). </param>
+        /// <param name="binary">(For images only) If the flag is non-zero, all the zero pixel values are treated as zeroes, all the others are treated as 1’s. </param>
 #endif
         public CvMoments(CvArr arr, bool binary)

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Core/CvDll.cs

@@ -175 +175 @@
         public static extern IntPtr cvHoughLines2(IntPtr image, IntPtr line_storage, HoughLinesMethod method, double rho, double theta, int threshold, double param1, double param2);
         [DllImport(DLL_CV)]
-        public static extern IntPtr cvHoughCircles(IntPtr image, IntPtr circleStorage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius);
+        public static extern IntPtr cvHoughCircles(IntPtr image, IntPtr circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius);
         [DllImport(DLL_CV)]
         public static extern void cvInitSubdivDelaunay2D(IntPtr subdiv, CvRect rect);

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Core/Cv_D-H.cs

@@ -2924 +2924 @@
         }
         #endregion
+        #region HoughCircles
+        #region circle_storage = CvMemStorage
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, 100, 100, 0, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, 100, 0, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <param name="param2">手法に応じた2番目のパラメータ． CV_HOUGH_GRADIENT の場合は，中心検出計算時の閾値．小さすぎると誤検出が多くなる．これに対応する値が大きい円から順に検出される．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, 0, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <param name="param2">手法に応じた2番目のパラメータ． CV_HOUGH_GRADIENT の場合は，中心検出計算時の閾値．小さすぎると誤検出が多くなる．これに対応する値が大きい円から順に検出される．</param>
+        /// <param name="min_radius">検出すべき円の最小半径．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
+        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, min_radius, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <param name="param2">手法に応じた2番目のパラメータ． CV_HOUGH_GRADIENT の場合は，中心検出計算時の閾値．小さすぎると誤検出が多くなる．これに対応する値が大きい円から順に検出される．</param>
+        /// <param name="min_radius">検出すべき円の最小半径．</param>
+        /// <param name="max_radius">検出すべき円の最大半径 デフォルトの最大半径は max(image_width, image_height) にセットされている．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
+        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
+        /// <param name="max_radius">Maximal radius of the circles to search for. By default the maximal radius is set to max(image_width, image_height). </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
+        {
+            if (image == null)
+                throw new ArgumentNullException("image");
+            if (circle_storage == null)
+                throw new ArgumentNullException("circle_storage");
+            IntPtr result = CvDll.cvHoughCircles(image.CvPtr, circle_storage.CvPtr, method, dp, min_dist, param1, param2, min_radius, max_radius);
+            if (result == IntPtr.Zero)
+                return null;
+            else
+                return new CvSeq<CvCircleSegment>(result);
+        }
+        #endregion
+        #region circle_storage = CvMat
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, 100, 100, 0, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, 100, 0, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <param name="param2">手法に応じた2番目のパラメータ． CV_HOUGH_GRADIENT の場合は，中心検出計算時の閾値．小さすぎると誤検出が多くなる．これに対応する値が大きい円から順に検出される．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, 0, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <param name="param2">手法に応じた2番目のパラメータ． CV_HOUGH_GRADIENT の場合は，中心検出計算時の閾値．小さすぎると誤検出が多くなる．これに対応する値が大きい円から順に検出される．</param>
+        /// <param name="min_radius">検出すべき円の最小半径．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
+        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius)
+        {
+            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, min_radius, 0);
+        }
+#if LANG_JP
+        /// <summary>
+        /// ハフ変換を用いてグレースケール画像中の円を検出する
+        /// </summary>
+        /// <param name="image">入力画像 （8ビット，シングルチャンネル，グレースケール）．</param>
+        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
+        /// <param name="method">現状では，CV_HOUGH_GRADIENT（基本的な2段階のハフ変換）のみ実装されている. </param>
+        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度．例えば，この値が 1 の場合は，計算は入力画像と同じ解像度で行われる．2 の場合は，計算は幅・高さともに1/2の解像度になる，等． </param>
+        /// <param name="min_dist">円検出における中心座標間の最小間隔．この値が非常に小さい場合は，正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる．また，逆に非常に大きい場合は，円検出に失敗する． </param>
+        /// <param name="param1">手法に応じた1番目のパラメータ． CV_HOUGH_GRADIENT の場合は，Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は，この値を1/2したものになる）．</param>
+        /// <param name="param2">手法に応じた2番目のパラメータ． CV_HOUGH_GRADIENT の場合は，中心検出計算時の閾値．小さすぎると誤検出が多くなる．これに対応する値が大きい円から順に検出される．</param>
+        /// <param name="min_radius">検出すべき円の最小半径．</param>
+        /// <param name="max_radius">検出すべき円の最大半径 デフォルトの最大半径は max(image_width, image_height) にセットされている．</param>
+        /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds circles in grayscale image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
+        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
+        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
+        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
+        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
+        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
+        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
+        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
+        /// <param name="max_radius">Maximal radius of the circles to search for. By default the maximal radius is set to max(image_width, image_height). </param>
+        /// <returns></returns>
+#endif
+        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
+        {
+            if (image == null)
+                throw new ArgumentNullException("image");
+            if (circle_storage == null)
+                throw new ArgumentNullException("circle_storage");
+            IntPtr result = CvDll.cvHoughCircles(image.CvPtr, circle_storage.CvPtr, method, dp, min_dist, param1, param2, min_radius, max_radius);
+            if (result == IntPtr.Zero)
+                return null;
+            else
+                return new CvSeq<CvCircleSegment>(result);
+        }
+        #endregion
+        #endregion
         #region HoughLines2
+#if LANG_JP
         /// <summary>
         /// ハフ（Hough）変換を用いて2値画像から直線を検出する
@@ -2935 +3248 @@
         /// <param name="threshold">閾値パラメータ．対応する投票数がthresholdより大きい場合のみ，抽出された線が返される．</param>
         /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds lines in binary image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
+        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
+        /// <param name="method">The Hough transform variant.</param>
+        /// <param name="rho">Distance resolution in pixel-related units. </param>
+        /// <param name="theta">Angle resolution measured in radians. </param>
+        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
+        /// <returns></returns>
+#endif
         public static CvSeq HoughLines2(this CvArr image, CvMemStorage line_storage, HoughLinesMethod method, double rho, double theta, int threshold)
         {
             return HoughLines2(image, line_storage, method, rho, theta, threshold, 0, 0);
         }
+#if LANG_JP
         /// <summary>
         /// ハフ（Hough）変換を用いて2値画像から直線を検出する
@@ -2951 +3277 @@
         /// <param name="param2">各手法に応じた２番目のパラメータ．標準的ハフ変換では，使用しない（0）．確率的ハフ変換では，同一線上に存在する線分として扱う（つまり，それらを統合しても問題ない），二つの線分の最大の間隔． マルチスケールハフ変換では，角度解像度 thetaの除数． （荒い角度解像度では theta であり，詳細な解像度では (theta / param2) となる）． </param>
         /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds lines in binary image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
+        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
+        /// <param name="method">The Hough transform variant.</param>
+        /// <param name="rho">Distance resolution in pixel-related units. </param>
+        /// <param name="theta">Angle resolution measured in radians. </param>
+        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
+        /// <param name="param1">The first method-dependent parameter.</param>
+        /// <param name="param2">The second method-dependent parameter.</param>
+        /// <returns></returns>
+#endif
         public static CvSeq HoughLines2(this CvArr image, CvMemStorage line_storage, HoughLinesMethod method, double rho, double theta, int threshold, double param1, double param2)
         {
@@ -2960 +3300 @@
             return new CvSeq(result);
         }
+#if LANG_JP
         /// <summary>
         /// ハフ（Hough）変換を用いて2値画像から直線を検出する
@@ -2970 +3311 @@
         /// <param name="threshold">閾値パラメータ．対応する投票数がthresholdより大きい場合のみ，抽出された線が返される．</param>
         /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds lines in binary image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
+        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
+        /// <param name="method">The Hough transform variant.</param>
+        /// <param name="rho">Distance resolution in pixel-related units. </param>
+        /// <param name="theta">Angle resolution measured in radians. </param>
+        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
+        /// <returns></returns>
+#endif
         public static CvSeq HoughLines2(this CvArr image, CvMat line_storage, HoughLinesMethod method, double rho, double theta, int threshold)
         {
             return HoughLines2(image, line_storage, method, rho, theta, threshold, 0, 0);
         }
+#if LANG_JP
         /// <summary>
         /// ハフ（Hough）変換を用いて2値画像から直線を検出する
@@ -2986 +3340 @@
         /// <param name="param2">各手法に応じた２番目のパラメータ．標準的ハフ変換では，使用しない（0）．確率的ハフ変換では，同一線上に存在する線分として扱う（つまり，それらを統合しても問題ない），二つの線分の最大の間隔． マルチスケールハフ変換では，角度解像度 thetaの除数． （荒い角度解像度では theta であり，詳細な解像度では (theta / param2) となる）． </param>
         /// <returns></returns>
+#else
+        /// <summary>
+        /// Finds lines in binary image using Hough transform.
+        /// </summary>
+        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
+        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
+        /// <param name="method">The Hough transform variant.</param>
+        /// <param name="rho">Distance resolution in pixel-related units. </param>
+        /// <param name="theta">Angle resolution measured in radians. </param>
+        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
+        /// <param name="param1">The first method-dependent parameter.</param>
+        /// <param name="param2">The second method-dependent parameter.</param>
+        /// <returns></returns>
+#endif
         public static CvSeq HoughLines2(this CvArr image, CvMat line_storage, HoughLinesMethod method, double rho, double theta, int threshold, double param1, double param2)
         {

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/OpenCvSharp.csproj

@@ -4 +4 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
+    <ProductVersion>9.0.30729</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{4C2356B8-1A1E-4F92-A51C-A49CA116867F}</ProjectGuid>
@@ -166 +166 @@
     <Compile Include="Enum\PCAFlag.cs" />
     <Compile Include="Enum\ConvertImageFlag.cs" />
+    <Compile Include="Struct\CvCircleSegment.cs" />
     <Compile Include="Tool\ArrayAddress.cs" />
     <Compile Include="Class\CvConnectedComp.cs" />

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Struct/CvLineSegmentPoint.cs

@@ -7 +7 @@
 namespace KwsmLab.OpenCvSharp
 {
+#if LANG_JP
     /// <summary>
     /// cvHoughLines2で得られる、両端の点で表現される線分
     /// </summary>
+#else
+    /// <summary>
+    /// Line segment structure retrieved by cvHoughLines2
+    /// </summary>
+#endif
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
     public struct CvLineSegmentPoint : IEquatable<CvLineSegmentPoint>
     {
+#if LANG_JP
         /// <summary>
         /// 1つ目の点
         /// </summary>
+#else
+        /// <summary>
+        /// 1st Point
+        /// </summary>
+#endif
         public CvPoint P1;
+#if LANG_JP
         /// <summary>
         /// 2つ目の点
         /// </summary>
+#else
+        /// <summary>
+        /// 2nd Point
+        /// </summary>
+#endif
         public CvPoint P2;
 
 
+#if LANG_JP
         /// <summary>
         /// 初期化
@@ -29 +48 @@
         /// <param name="p1">1つ目の点</param>
         /// <param name="p2">2つ目の点</param>
+#else
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="p1">1st Point</param>
+        /// <param name="p2">2nd Point</param>
+#endif
         public CvLineSegmentPoint(CvPoint p1, CvPoint p2)
         {

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Struct/CvLineSegmentPolar.cs

@@ -7 +7 @@
 namespace KwsmLab.OpenCvSharp
 {
+#if LANG_JP
     /// <summary>
     /// cvHoughLines2で得られる、極座標系で表現される線分
     /// </summary>
+#else
+    /// <summary>
+    /// Polar line segment retrieved by cvHoughLines2
+    /// </summary>
+#endif
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
     public struct CvLineSegmentPolar : IEquatable<CvLineSegmentPolar>
     {
+#if LANG_JP
         /// <summary>
         /// 線分の長さ
         /// </summary>
+#else
+        /// <summary>
+        /// Length of the line
+        /// </summary>
+#endif
         public float Rho;
+#if LANG_JP
         /// <summary>
         /// 線分の角度(ラジアン)
         /// </summary>
+#else
+        /// <summary>
+        /// Angle of the line (radian)
+        /// </summary>
+#endif
         public float Theta;
 
 
+#if LANG_JP
         /// <summary>
         /// 初期化
@@ -29 +48 @@
         /// <param name="rho">線分の長さ</param>
         /// <param name="theta">線分の角度(ラジアン)</param>
+#else
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="rho">Length of the line</param>
+        /// <param name="theta">Angle of the line (radian)</param>
+#endif
         public CvLineSegmentPolar(float rho, float theta)
         {