root/lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Core/Cv_A-F.cs @ 31838

Revision 31838, 246.4 kB (checked in by schima, 6 years ago)

added japanese xml comments

Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Runtime.InteropServices;
5using System.Text;
6using KwsmLab.OpenCvSharp.Extern;
7
8namespace KwsmLab.OpenCvSharp
9{
10    /// <summary>
11    /// OpenCvのcvXXX関数のラッパー。
12    /// IntPtrを使わずにラッパークラスを使って、ネイティブのOpenCVに近い感じで自然にアクセスできる。
13    /// </summary>
14    public static partial class Cv
15    {
16        #region _2DRotationMatrix
17        /// <summary>
18        /// 2次元回転のアフィン行列を計算する (2 x 3 のCV_32FC1型). 引数としてoutを取るオーバーロードの簡略版.
19        /// おそらくoutで出てくる行列と関数の返り値は同じなので、out引数の方を省いたものである.
20        /// </summary>
21        /// <param name="center">入力画像内の回転中心 </param>
22        /// <param name="angle">度(degree)単位の回転角度.正の値は反時計方向の回転を意味する(座標原点は左上にあると仮定).</param>
23        /// <param name="scale">等方性スケーリング係数(x,y方向とも同じ係数 scale を使う) </param>
24        /// <returns>2x3の2次元回転のアフィン行列</returns>
25        public static CvMat _2DRotationMatrix(CvPoint2D32f center, double angle, double scale)
26        {
27            CvMat map_matrix;
28            return _2DRotationMatrix(center, angle, scale, out map_matrix);
29        }
30        /// <summary>
31        /// 2次元回転のアフィン行列を計算する (2 x 3 のCV_32FC1型).
32        /// </summary>
33        /// <param name="center">入力画像内の回転中心 </param>
34        /// <param name="angle">度(degree)単位の回転角度.正の値は反時計方向の回転を意味する(座標原点は左上にあると仮定).</param>
35        /// <param name="scale">等方性スケーリング係数(x,y方向とも同じ係数 scale を使う) </param>
36        /// <param name="map_matrix">出力される 2x3の行列</param>
37        /// <returns>2x3の2次元回転のアフィン行列</returns>
38        public static CvMat _2DRotationMatrix(CvPoint2D32f center, double angle, double scale, out CvMat map_matrix)
39        {
40            IntPtr map_matrix_ptr = CvDll.cvCreateMat(2, 3, MatrixType.F32C1);
41            CvDll.cv2DRotationMatrix(center, angle, scale, map_matrix_ptr);
42            map_matrix = new CvMat(map_matrix_ptr);
43            return map_matrix;
44        }
45        #endregion
46        #region AbsDiff
47        /// <summary>
48        /// 二つの配列の要素ごとの差の絶対値を計算する.
49        /// dst(I) = abs(src1(I) - src2(I)).
50        /// すべての配列は同じタイプ,同じサイズ(または同じROIサイズ)でなければならない.
51        /// </summary>
52        /// <param name="src1">1番目の入力画像</param>
53        /// <param name="src2">2番目の入力画像</param>
54        /// <param name="dst">出力画像</param>
55        public static void AbsDiff(CvArr src1, CvArr src2, CvArr dst)
56        {
57            if (src1 == null)
58                throw new ArgumentNullException("src1");
59            if (src2 == null)
60                throw new ArgumentNullException("src2");
61            if (dst == null)
62                throw new ArgumentNullException("dst");
63            CvDll.cvAbsDiff(src1.CvPtr, src2.CvPtr, dst.CvPtr);
64        }
65        #endregion
66        #region AbsDiffS
67        /// <summary>
68        /// 配列の要素と定数との差の絶対値を計算する.
69        /// dst(I) = abs(src(I) - value).
70        /// すべての配列は同じタイプ,同じサイズ(または同じROIサイズ)でなければならない.
71        /// </summary>
72        /// <param name="src">1番目の入力画像</param>
73        /// <param name="dst">出力画像</param>
74        /// <param name="value">スカラー</param>
75        public static void AbsDiffS(this CvArr src, CvArr dst, CvScalar value)
76        {
77            if (src == null)
78                throw new ArgumentNullException("src");
79            if (dst == null)
80                throw new ArgumentNullException("dst");
81            CvDll.cvAbsDiffS(src.CvPtr, dst.CvPtr, value);
82        }
83        /// <summary>
84        /// 配列の要素の絶対値を計算する.
85        /// dst(I) = abs(src(I)).
86        /// すべての配列は同じタイプ,同じサイズ(または同じROIサイズ)でなければならない.
87        /// </summary>
88        /// <param name="src">入力画像</param>
89        /// <param name="dst">出力画像</param>
90        public static void Abs(this CvArr src, CvArr dst)
91        {
92            if (src == null)
93                throw new ArgumentNullException("src");
94            if (dst == null)
95                throw new ArgumentNullException("dst");
96            CvDll.cvAbsDiffS(src.CvPtr, dst.CvPtr, CvScalar.ScalarAll(0));
97        }
98        #endregion
99        #region Acc
100        /// <summary>
101        /// アキュムレータにフレームを加算する
102        /// </summary>
103        /// <param name="image">入力画像.1 または 3 チャンネル,8 ビットあるいは 32 ビット浮動小数点型.</param>
104        /// <param name="sum">入力画像と同じチャンネル数のアキュムレータ,32 ビットあるいは 64 ビット浮動小数点型.</param>
105        public static void Acc(this CvArr image, CvArr sum)
106        {
107            Acc(image, sum);
108        }
109        /// <summary>
110        /// アキュムレータにフレームを加算する
111        /// </summary>
112        /// <param name="image">入力画像.1 または 3 チャンネル,8 ビットあるいは 32 ビット浮動小数点型.</param>
113        /// <param name="sum">入力画像と同じチャンネル数のアキュムレータ,32 ビットあるいは 64 ビット浮動小数点型.</param>
114        /// <param name="mask">オプションの処理マスク.</param>
115        public static void Acc(this CvArr image, CvArr sum, CvArr mask)
116        {
117            if (image == null)
118                throw new ArgumentNullException("image");
119            if (sum == null)
120                throw new ArgumentNullException("dst");
121            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
122            CvDll.cvAcc(image.CvPtr, sum.CvPtr, maskPtr);
123        }
124        #endregion
125        #region AdaptiveThreshold
126        /// <summary>
127        /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する
128        /// </summary>
129        /// <param name="src">入力画像</param>
130        /// <param name="dst">出力画像</param>
131        /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param>
132        public static void AdaptiveThreshold(this CvArr src, CvArr dst, double max_value)
133        {
134            AdaptiveThreshold(src, dst, max_value, AdaptiveThresholdType.MeanC, ThresholdType.Binary, 3, 5);
135        }
136        /// <summary>
137        /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する
138        /// </summary>
139        /// <param name="src">入力画像</param>
140        /// <param name="dst">出力画像</param>
141        /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param>
142        /// <param name="adaptive_method">適応的閾値処理で使用するアルゴリズム</param>
143        public static void AdaptiveThreshold(this CvArr src, CvArr dst, double max_value, AdaptiveThresholdType adaptive_method)
144        {
145            AdaptiveThreshold(src, dst, max_value, adaptive_method, ThresholdType.Binary);
146        }
147        /// <summary>
148        /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する
149        /// </summary>
150        /// <param name="src">入力画像</param>
151        /// <param name="dst">出力画像</param>
152        /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param>
153        /// <param name="adaptive_method">適応的閾値処理で使用するアルゴリズム</param>
154        /// <param name="threshold_type">閾値処理の種類. BinaryかBinaryInvのどちらか</param>
155        public static void AdaptiveThreshold(this CvArr src, CvArr dst, double max_value, AdaptiveThresholdType adaptive_method, ThresholdType threshold_type)
156        {
157            AdaptiveThreshold(src, dst, max_value, adaptive_method, threshold_type, 3, 5);
158        }
159        /// <summary>
160        /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する
161        /// </summary>
162        /// <param name="src">入力画像</param>
163        /// <param name="dst">出力画像</param>
164        /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param>
165        /// <param name="adaptive_method">適応的閾値処理で使用するアルゴリズム</param>
166        /// <param name="threshold_type">閾値処理の種類. BinaryかBinaryInvのどちらか</param>
167        /// <param name="block_size">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param>
168        public static void AdaptiveThreshold(this CvArr src, CvArr dst, double max_value, AdaptiveThresholdType adaptive_method, ThresholdType threshold_type, Int32 block_size)
169        {
170            AdaptiveThreshold(src, dst, max_value, adaptive_method, threshold_type, block_size, 5);
171        }
172        /// <summary>
173        /// 適応的な閾値処理を行い、グレースケール画像を2値画像に変換する
174        /// </summary>
175        /// <param name="src">入力画像</param>
176        /// <param name="dst">出力画像</param>
177        /// <param name="max_value">threshold_type がBinaryあるいはBinaryInvのときに用いる最大値</param>
178        /// <param name="adaptive_method">適応的閾値処理で使用するアルゴリズム</param>
179        /// <param name="threshold_type">閾値処理の種類. BinaryかBinaryInvのどちらか</param>
180        /// <param name="block_size">ピクセルの閾値を計算するために用いる隣接領域のサイズ: 3, 5, 7, ... </param>
181        /// <param name="param1">各適応手法に応じたパラメータ. 適応手法がMeanCおよびGaussianCの場合は,平均値または重み付き平均値から引く定数. 負の値の場合もある.</param>
182        public static void AdaptiveThreshold(this CvArr src, CvArr dst, double max_value, AdaptiveThresholdType adaptive_method, ThresholdType threshold_type, int block_size, double param1)
183        {
184            if (src == null)
185                throw new ArgumentNullException("src");
186            if (dst == null)
187                throw new ArgumentNullException("dst");
188
189            if (threshold_type != ThresholdType.Binary && threshold_type != ThresholdType.BinaryInv)
190            {
191                throw new ArgumentOutOfRangeException("閾値処理の種類は、BinaryかBinaryInvのどちらかである必要があります。");
192            }
193            CvDll.cvAdaptiveThreshold(src.CvPtr, dst.CvPtr, max_value, adaptive_method, threshold_type, block_size, param1);
194        }
195        #endregion
196        #region Add
197        /// <summary>
198        /// 二つの配列を要素ごとに加算する.
199        /// dst(I)=src1(I)+src2(I)
200        /// </summary>
201        /// <param name="src1">1番目の入力配列</param>
202        /// <param name="src2">2番目の入力配列</param>
203        /// <param name="dst">出力配列</param>
204        public static void Add(this CvArr src1, CvArr src2, CvArr dst)
205        {
206            Add(src1, src2, dst, null);
207        }
208        /// <summary>
209        /// 二つの配列を要素ごとに加算する.
210        /// dst(I)=src1(I)+src2(I) [mask(I)!=0の場合]
211        /// </summary>
212        /// <param name="src1">1番目の入力配列</param>
213        /// <param name="src2">2番目の入力配列</param>
214        /// <param name="dst">出力配列</param>
215        /// <param name="mask">処理マスク.8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する). </param>
216        public static void Add(this CvArr src1, CvArr src2, CvArr dst, CvArr mask)
217        {
218            if (src1 == null)
219                throw new ArgumentNullException("src1");
220            if (src2 == null)
221                throw new ArgumentNullException("src2");
222            if (dst == null)
223                throw new ArgumentNullException("dst");
224            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
225            CvDll.cvAdd(src1.CvPtr, src2.CvPtr, dst.CvPtr, maskPtr);
226        }
227        #endregion
228        #region AddS
229        /// <summary>
230        /// 入力配列 src1 のすべての要素にスカラー value を加え,結果を dst に保存する.
231        /// dst(I)=src(I)+value
232        /// </summary>
233        /// <param name="src1">入力配列</param>
234        /// <param name="value">加算するスカラー</param>
235        /// <param name="dst">出力配列</param>
236        public static void AddS(this CvArr src1, CvScalar value, CvArr dst)
237        {
238            AddS(src1, value, dst, null);
239        }
240        /// <summary>
241        /// 入力配列 src1 のすべての要素にスカラー value を加え,結果を dst に保存する.
242        /// dst(I)=src(I)+value [mask(I)!=0 の場合]
243        /// </summary>
244        /// <param name="src1">入力配列</param>
245        /// <param name="value">加算するスカラー</param>
246        /// <param name="dst">出力配列</param>
247        /// <param name="mask">処理マスク.8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する).</param>
248        public static void AddS(CvArr src1, CvScalar value, CvArr dst, CvArr mask)
249        {
250            if (src1 == null)
251                throw new ArgumentNullException("src1");
252            if (dst == null)
253                throw new ArgumentNullException("dst");
254            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
255            CvDll.cvAddS(src1.CvPtr, value, dst.CvPtr, maskPtr);
256        }
257        #endregion
258        #region Addweighted
259        /// <summary>
260        /// 入力配列 src1 のすべての要素にスカラー value を加え,結果を dst に保存する.
261        /// dst(I) = src1(I)*alpha + src2(I)*beta + gamma
262        /// </summary>
263        /// <param name="src1">1番目の入力配列</param>
264        /// <param name="alpha">1番目の配列要素への重み</param>
265        /// <param name="src2">2番目の入力配列スカラー</param>
266        /// <param name="beta">2番目の配列要素への重み</param>
267        /// <param name="gamma">加算結果に,さらに加えられるスカラー値</param>
268        /// <param name="dst">出力配列</param>
269        public static void AddWeighted(this CvArr src1, double alpha, CvArr src2, double beta, double gamma, CvArr dst)
270        {
271            if (src1 == null)
272                throw new ArgumentNullException("src1");
273            if (src2 == null)
274                throw new ArgumentNullException("src2");
275            if (dst == null)
276                throw new ArgumentNullException("dst");
277            CvDll.cvAddWeighted(src1.CvPtr, alpha, src2.CvPtr, beta, gamma, dst.CvPtr);
278        }
279        #endregion
280        #region Alloc
281#if LANG_JA
282/// <summary>
283        ///
284        /// </summary>
285         /// <param name="size"></param>
286        /// <returns></returns>
287#else
288        /// <summary>
289        /// Allocates memory buffer
290        /// </summary>
291        /// <param name="size">Buffer size in bytes. </param>
292        /// <returns></returns>
293
294#endif
295        public static IntPtr Alloc(uint size)
296        {
297
298            return CvDll.cvAlloc(size);
299        }
300        #endregion
301        #region And
302        /// <summary>
303        /// 二つの配列の要素ごとの論理積(AND)を計算する.
304        /// dst(I)=src1(I)&amp;src2(I)
305        /// </summary>
306        /// <param name="src1">1番目の入力配列</param>
307        /// <param name="src2">2番目の入力配列</param>
308        /// <param name="dst">出力配列</param>
309        public static void And(this CvArr src1, CvArr src2, CvArr dst)
310        {
311            And(src1, src2, dst, null);
312        }
313        /// <summary>
314        /// 二つの配列の要素ごとの論理積(AND)を計算する.
315        /// dst(I)=src1(I)&amp;src2(I) [mask(I)!=0の場合]
316        /// </summary>
317        /// <param name="src1">1番目の入力配列</param>
318        /// <param name="src2">2番目の入力配列</param>
319        /// <param name="dst">出力配列</param>
320        /// <param name="mask">処理マスク.8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する). </param>
321        public static void And(this CvArr src1, CvArr src2, CvArr dst, CvArr mask)
322        {
323            if (src1 == null)
324                throw new ArgumentNullException("src1");
325            if (src2 == null)
326                throw new ArgumentNullException("src2");
327            if (dst == null)
328                throw new ArgumentNullException("dst");
329            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
330            CvDll.cvAnd(src1.CvPtr, src2.CvPtr, dst.CvPtr, maskPtr);
331        }
332        #endregion
333        #region AndS
334        /// <summary>
335        /// 配列の各要素とスカラーとのビット単位の論理積(AND)を計算する.
336        /// 実際の計算の前に,スカラーは配列と同じタイプに変換される.浮動小数点型配列の場合,それらのビット表現が処理に使われる.
337        /// すべての配列(マスクを除く)は同じタイプで,配列のサイズ(またはROIのサイズ)も同じでなければならない.
338        /// dst(I)=src(I)&amp;value
339        /// </summary>
340        /// <param name="src1">入力配列</param>
341        /// <param name="value">処理に用いるスカラー</param>
342        /// <param name="dst">出力配列</param>
343        public static void AndS(this CvArr src1, CvScalar value, CvArr dst)
344        {
345            AndS(src1, value, dst);
346        }
347        /// <summary>
348        /// 配列の各要素とスカラーとのビット単位の論理積(AND)を計算する.
349        /// 実際の計算の前に,スカラーは配列と同じタイプに変換される.浮動小数点型配列の場合,それらのビット表現が処理に使われる.
350        /// すべての配列(マスクを除く)は同じタイプで,配列のサイズ(またはROIのサイズ)も同じでなければならない.
351        /// dst(I)=src(I)&amp;value [mask(I)!=0の場合]
352        /// </summary>
353        /// <param name="src1">入力配列</param>
354        /// <param name="value">処理に用いるスカラー</param>
355        /// <param name="dst">出力配列</param>
356        /// <param name="mask">処理マスク.8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する).</param>
357        public static void AndS(this CvArr src1, CvScalar value, CvArr dst, CvArr mask)
358        {
359            if (src1 == null)
360                throw new ArgumentNullException("src1");
361            if (dst == null)
362                throw new ArgumentNullException("dst");
363            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
364            CvDll.cvAndS(src1.CvPtr, value, dst.CvPtr, maskPtr);
365        }
366        #endregion
367        #region ApproxChains
368#if LANG_JA
369/// <summary>
370        ///
371        /// </summary>
372        /// <param name="src_seq"></param>
373        /// <param name="storage"></param>
374        /// <returns></returns>
375#else
376        /// <summary>
377        /// Approximates Freeman chain(s) with polygonal curve
378        /// </summary>
379        /// <param name="src_seq">Freeman chain(s) </param>
380        /// <param name="storage">Storage location for the resulting polylines. </param>
381        /// <returns></returns>
382#endif
383        public static CvSeq<CvPoint> ApproxChains(this CvChain<CvPoint> src_seq, CvMemStorage storage)
384        {
385            return ApproxChains(src_seq, storage, ContourChain.ApproxSimple);
386        }
387#if LANG_JA
388/// <summary>
389        ///
390        /// </summary>
391        /// <param name="src_seq"></param>
392        /// <param name="storage"></param>
393        /// <param name="method"></param>
394        /// <returns></returns>
395#else
396        /// <summary>
397        /// Approximates Freeman chain(s) with polygonal curve
398        /// </summary>
399        /// <param name="src_seq">Freeman chain(s) </param>
400        /// <param name="storage">Storage location for the resulting polylines. </param>
401        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).
402        /// * CV_CHAIN_CODE - output contours in the Freeman chain code. All other methods output polygons (sequences of vertices).
403        /// * CV_CHAIN_APPROX_NONE - translate all the points from the chain code into points;
404        /// * CV_CHAIN_APPROX_SIMPLE - compress horizontal, vertical, and diagonal segments, that is, the function leaves only their ending points;
405        /// * CV_CHAIN_APPROX_TC89_L1,
406        /// * CV_CHAIN_APPROX_TC89_KCOS - apply one of the flavors of Teh-Chin chain approximation algorithm. CV_LINK_RUNS - use completely different contour retrieval algorithm via linking of horizontal segments of 1’s. Only CV_RETR_LIST retrieval mode can be used with this method. </param>
407        /// <returns></returns>
408#endif
409        public static CvSeq<CvPoint> ApproxChains(this CvChain<CvPoint> src_seq, CvMemStorage storage, ContourChain method)
410        {
411            return ApproxChains(src_seq, storage, method, 0);
412        }
413#if LANG_JA
414/// <summary>
415        ///
416        /// </summary>
417        /// <param name="src_seq"></param>
418        /// <param name="storage"></param>
419        /// <param name="method"></param>
420        /// <param name="parameter"></param>
421        /// <returns></returns>
422#else
423        /// <summary>
424        /// Approximates Freeman chain(s) with polygonal curve
425        /// </summary>
426        /// <param name="src_seq">Freeman chain(s) </param>
427        /// <param name="storage">Storage location for the resulting polylines. </param>
428        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).
429        /// * CV_CHAIN_CODE - output contours in the Freeman chain code. All other methods output polygons (sequences of vertices).
430        /// * CV_CHAIN_APPROX_NONE - translate all the points from the chain code into points;
431        /// * CV_CHAIN_APPROX_SIMPLE - compress horizontal, vertical, and diagonal segments, that is, the function leaves only their ending points;
432        /// * CV_CHAIN_APPROX_TC89_L1,
433        /// * CV_CHAIN_APPROX_TC89_KCOS - apply one of the flavors of Teh-Chin chain approximation algorithm. CV_LINK_RUNS - use completely different contour retrieval algorithm via linking of horizontal segments of 1’s. Only CV_RETR_LIST retrieval mode can be used with this method. </param>
434        /// <param name="parameter">Method parameter (not used now). </param>
435        /// <returns></returns>
436#endif
437        public static CvSeq<CvPoint> ApproxChains(this CvChain<CvPoint> src_seq, CvMemStorage storage, ContourChain method, double parameter)
438        {
439            return ApproxChains(src_seq, storage, method, parameter, 0);
440        }
441#if LANG_JA
442/// <summary>
443        ///
444        /// </summary>
445        /// <param name="src_seq"></param>
446        /// <param name="storage"></param>
447        /// <param name="method"></param>
448        /// <param name="parameter"></param>
449        /// <param name="minimal_perimeter"></param>
450        /// <returns></returns>
451#else
452        /// <summary>
453        /// Approximates Freeman chain(s) with polygonal curve
454        /// </summary>
455        /// <param name="src_seq">Freeman chain(s) </param>
456        /// <param name="storage">Storage location for the resulting polylines. </param>
457        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).
458        /// * CV_CHAIN_CODE - output contours in the Freeman chain code. All other methods output polygons (sequences of vertices).
459        /// * CV_CHAIN_APPROX_NONE - translate all the points from the chain code into points;
460        /// * CV_CHAIN_APPROX_SIMPLE - compress horizontal, vertical, and diagonal segments, that is, the function leaves only their ending points;
461        /// * CV_CHAIN_APPROX_TC89_L1,
462        /// * CV_CHAIN_APPROX_TC89_KCOS - apply one of the flavors of Teh-Chin chain approximation algorithm. CV_LINK_RUNS - use completely different contour retrieval algorithm via linking of horizontal segments of 1’s. Only CV_RETR_LIST retrieval mode can be used with this method. </param>
463        /// <param name="parameter">Method parameter (not used now). </param>
464        /// <param name="minimal_perimeter">Approximates only those contours whose perimeters are not less than minimal_perimeter. Other chains are removed from the resulting structure. </param>
465        /// <returns></returns>
466#endif
467        public static CvSeq<CvPoint> ApproxChains(this CvChain<CvPoint> src_seq, CvMemStorage storage, ContourChain method, double parameter, int minimal_perimeter)
468        {
469            return ApproxChains(src_seq, storage, method, parameter, minimal_perimeter, 0);
470        }
471#if LANG_JA
472/// <summary>
473        ///
474        /// </summary>
475        /// <param name="src_seq"></param>
476        /// <param name="storage"></param>
477        /// <param name="method"></param>
478        /// <param name="parameter"></param>
479        /// <param name="minimal_perimeter"></param>
480        /// <param name="recursive"></param>
481        /// <returns></returns>
482#else
483        /// <summary>
484        /// Approximates Freeman chain(s) with polygonal curve
485        /// </summary>
486        /// <param name="src_seq">Freeman chain(s) </param>
487        /// <param name="storage">Storage location for the resulting polylines. </param>
488        /// <param name="method">Approximation method (for all the modes, except CV_RETR_RUNS, which uses built-in approximation).
489        /// * CV_CHAIN_CODE - output contours in the Freeman chain code. All other methods output polygons (sequences of vertices).
490        /// * CV_CHAIN_APPROX_NONE - translate all the points from the chain code into points;
491        /// * CV_CHAIN_APPROX_SIMPLE - compress horizontal, vertical, and diagonal segments, that is, the function leaves only their ending points;
492        /// * CV_CHAIN_APPROX_TC89_L1,
493        /// * CV_CHAIN_APPROX_TC89_KCOS - apply one of the flavors of Teh-Chin chain approximation algorithm. CV_LINK_RUNS - use completely different contour retrieval algorithm via linking of horizontal segments of 1’s. Only CV_RETR_LIST retrieval mode can be used with this method. </param>
494        /// <param name="parameter">Method parameter (not used now). </param>
495        /// <param name="minimal_perimeter">Approximates only those contours whose perimeters are not less than minimal_perimeter. Other chains are removed from the resulting structure. </param>
496        /// <param name="recursive">If not 0, the function approximates all chains that access can be obtained to from src_seq by h_next or v_next links. If 0, the single chain is approximated. </param>
497        /// <returns></returns>
498#endif
499        public static CvSeq<CvPoint> ApproxChains(this CvChain<CvPoint> src_seq, CvMemStorage storage, ContourChain method, double parameter, int minimal_perimeter, int recursive)
500        {
501            if (src_seq == null)
502                throw new ArgumentNullException("image");
503            if (storage == null)
504                throw new ArgumentNullException("storage");
505            IntPtr result_ptr = CvDll.cvApproxChains(src_seq.CvPtr, storage.CvPtr, method, parameter, minimal_perimeter, recursive);
506            if (result_ptr == IntPtr.Zero)
507            {
508                return null;
509            }
510            else
511            {
512                CvSeq<CvPoint> result = new CvSeq<CvPoint>(result_ptr);
513                return result;
514            }
515
516        }
517        #endregion
518        #region ApproxPoly
519        /// <summary>
520        /// 指定した精度でポリラインを近似する
521        /// </summary>
522        /// <param name="src_seq">点のシーケンスまたは配列</param>
523        /// <param name="header_size">近似されたポリラインのヘッダサイズ.</param>
524        /// <param name="storage">近似された輪郭の保存場所.nullの場合,入力シーケンスのストレージが使われる. </param>
525        /// <param name="method">近似方法</param>
526        /// <param name="parameter">近似方法に依存するパラメータ.CV_POLY_APPROX_DPの場合には,要求する近似精度である.</param>
527        /// <returns>単一もしくは複数の近似曲線を計算した結果</returns>
528        public static CvSeq<CvPoint> ApproxPoly(this CvSeq<CvPoint> src_seq, Int32 header_size, CvMemStorage storage, ApproxPolyMethod method, double parameter)
529        {
530            return ApproxPoly(src_seq, header_size, storage, method, parameter, false);
531        }
532        /// <summary>
533        /// 指定した精度でポリラインを近似する
534        /// </summary>
535        /// <param name="src_seq">点のシーケンスまたは配列</param>
536        /// <param name="header_size">近似されたポリラインのヘッダサイズ.</param>
537        /// <param name="storage">近似された輪郭の保存場所.nullの場合,入力シーケンスのストレージが使われる. </param>
538        /// <param name="method">近似方法</param>
539        /// <param name="parameter">近似方法に依存するパラメータ.CV_POLY_APPROX_DPの場合には,要求する近似精度である.</param>
540        /// <param name="parameter2">src_seqが点の配列(CvMat)の場合, このパラメータは輪郭が閉じている(parameter2=true)か,開いているか(parameter2=false)を指定する.</param>
541        /// <returns>単一もしくは複数の近似曲線を計算した結果</returns>
542        public static CvSeq<CvPoint> ApproxPoly(this CvSeq<CvPoint> src_seq, Int32 header_size, CvMemStorage storage, ApproxPolyMethod method, double parameter, bool parameter2)
543        {
544            if (src_seq == null)
545            {
546                throw new ArgumentNullException("src_seq");
547            }
548            IntPtr storagePtr = (storage == null) ? IntPtr.Zero : storage.CvPtr;
549            IntPtr result = CvDll.cvApproxPoly(src_seq.CvPtr, header_size, storagePtr, method, parameter, parameter2);
550            if (result == IntPtr.Zero)
551            {
552                return null;
553            }
554            else
555            {
556                return new CvSeq<CvPoint>(result);
557            }
558        }
559        #endregion
560        #region ArcLength
561        /// <summary>
562        /// 輪郭の周囲長または曲線の長さを計算する
563        /// </summary>
564        /// <param name="curve">配列</param>
565        /// <returns>輪郭の周囲長または曲線の長さ</returns>
566        public static double ArcLength(this CvArr curve)
567        {
568            return ArcLength(curve, CvSlice.WholeSeq, -1);
569        }
570        /// <summary>
571        /// 輪郭の周囲長または曲線の長さを計算する
572        /// </summary>
573        /// <param name="curve">配列</param>
574        /// <param name="slice">曲線の始点と終点.デフォルトでは曲線の全ての長さが計算される.</param>
575        /// <returns>輪郭の周囲長または曲線の長さ</returns>
576        public static double ArcLength(this CvArr curve, CvSlice slice)
577        {
578            return ArcLength(curve, slice, -1);
579        }
580        /// <summary>
581        /// 輪郭の周囲長または曲線の長さを計算する
582        /// </summary>
583        /// <param name="curve">配列</param>
584        /// <param name="slice">曲線の始点と終点.デフォルトでは曲線の全ての長さが計算される.</param>
585        /// <param name="is_closed">閉曲線かどうかを示す.次の3つの状態がある:
586        /// is_closed=0 - 曲線は閉曲線として扱われない.
587        /// is_closed&gt;0 - 曲線は閉曲線として扱われる.
588        /// is_closed&lt;0 - 曲線がシーケンスの場合, ((CvSeq*)curve)-&gt;flagsのフラグCV_SEQ_FLAG_CLOSEDから閉曲線かどうかを判別する.そうでない(曲線が点の配列(CvMat*)で表現される)場合,閉曲線として扱われない.
589        /// </param>
590        /// <returns>輪郭の周囲長または曲線の長さ</returns>
591        public static double ArcLength(this CvArr curve, CvSlice slice, int is_closed)
592        {
593            if (curve == null)
594            {
595                throw new ArgumentNullException("curve");
596            }
597            return CvDll.cvArcLength(curve.CvPtr, slice, is_closed);
598        }
599        #endregion
600        #region Avg
601        /// <summary>
602        /// 配列要素の平均値を各チャンネルで独立に計算する.
603        /// </summary>
604        /// <param name="arr">配列</param>
605        /// <returns>平均値</returns>
606        public static CvScalar Avg(CvArr arr)
607        {
608            return Avg(arr, null);
609        }
610        /// <summary>
611        /// 配列要素の平均値を各チャンネルで独立に計算する.
612        /// </summary>
613        /// <param name="arr">配列</param>
614        /// <param name="mask">オプションの処理マスク</param>
615        /// <returns>平均値</returns>
616        public static CvScalar Avg(CvArr arr, CvArr mask)
617        {
618            if (arr == null)
619            {
620                throw new ArgumentNullException("arr");
621            }
622            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
623            return CvDll.cvAvg(arr.CvPtr, maskPtr);
624        }
625        #endregion
626        #region AvgSdv
627        /// <summary>
628        /// 配列要素の平均と標準偏差を各チャンネルで独立に計算する.
629        /// </summary>
630        /// <param name="arr">配列</param>
631        /// <param name="mean">計算結果の平均値の出力</param>
632        /// <param name="std_dev">計算結果の標準偏差の出力</param>
633        public static void AvgSdv(this CvArr arr, out CvScalar mean, out CvScalar std_dev)
634        {
635            AvgSdv(arr, out mean, out std_dev,null);
636        }
637        /// <summary>
638        /// 配列要素の平均と標準偏差を各チャンネルで独立に計算する.
639        /// </summary>
640        /// <param name="arr">配列</param>
641        /// <param name="mean">計算結果の平均値の出力</param>
642        /// <param name="std_dev">計算結果の標準偏差の出力</param>
643        /// <param name="mask">オプションの処理マスク</param>
644        public static void AvgSdv(this CvArr arr, out CvScalar mean, out CvScalar std_dev, CvArr mask)
645        {
646            if (arr == null)
647            {
648                throw new ArgumentNullException("arr");
649            }
650            mean = new CvScalar();
651            std_dev = new CvScalar();
652            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
653            CvDll.cvAvgSdv(arr.CvPtr, ref mean, ref std_dev, maskPtr);
654        }
655        #endregion
656        #region BackProjectPCA
657#if LANG_JA
658/// <summary>
659        ///
660        /// </summary>
661        /// <param name="proj"></param>
662        /// <param name="avg"></param>
663        /// <param name="eigenvects"></param>
664        /// <param name="result"></param>
665        /// <returns></returns>
666#else
667        /// <summary>
668        /// Reconstructs the original vectors from the projection coefficients
669        /// </summary>
670        /// <param name="proj">The input data; in the same format as result in cvProjectPCA. </param>
671        /// <param name="avg">The mean (average) vector. If it is a single-row vector, it means that the output vectors are stored as rows of result; otherwise, it should be a single-column vector, then the vectors are stored as columns of result. </param>
672        /// <param name="eigenvects">The eigenvectors (principal components); one vector per row. </param>
673        /// <param name="result">The output matrix of reconstructed vectors. </param>
674        /// <returns></returns>
675
676#endif
677        public static void BackProjectPCA(CvArr proj, CvArr avg, CvArr eigenvects, CvArr result)
678        {
679            if (proj == null)
680            {
681                throw new ArgumentNullException("proj");
682            }
683            if (avg == null)
684            {
685                throw new ArgumentNullException("avg");
686            }
687            if (eigenvects == null)
688            {
689                throw new ArgumentNullException("eigenvects");
690            }
691            CvDll.cvBackProjectPCA(proj.CvPtr, avg.CvPtr, eigenvects.CvPtr, result.CvPtr);
692        }
693        #endregion
694        #region BoundingRect
695        /// <summary>
696        /// 2次元点列を包含するまっすぐな矩形を返す.
697        /// </summary>
698        /// <param name="points">シーケンス(CvSeq, CvContour)か,点のベクトル(CvMat)か,非0のピクセルが点列とみなされる8ビット1チャンネルマスク画像 (CvMat, IplImage)のいずれかで表現された2次元の点列.</param>
699        /// <returns>矩形</returns>
700        public static CvRect BoundingRect(this CvArr points)
701        {
702            return BoundingRect(points, false);
703        }
704        /// <summary>
705        /// 2次元点列を包含するまっすぐな矩形を返す.
706        /// </summary>
707        /// <param name="points">シーケンス(CvSeq, CvContour)か,点のベクトル(CvMat)か,非0のピクセルが点列とみなされる8ビット1チャンネルマスク画像 (CvMat, IplImage)のいずれかで表現された2次元の点列.</param>
708        /// <param name="update">更新フラグ.
709        /// pointsがCvContour で,update=falseの場合: 包含矩形は計算されず,輪郭ヘッダのrectフィールドから読み込まれる.
710        /// pointsがCvContour で,update=trueの場合: 包含矩形は計算され,輪郭ヘッダのrectフィールドに書き込まれる.
711        /// pointsがCvSeqかCvMatの場合: updateは無視されて,包含矩形は計算されて返される. </param>
712        /// <returns>矩形</returns>
713        public static CvRect BoundingRect(this CvArr points, bool update)
714        {
715            if (points == null)
716            {
717                throw new ArgumentNullException("points");
718            }
719            return CvDll.cvBoundingRect(points.CvPtr, update);
720        }
721        /// <summary>
722        /// 2次元点列を包含するまっすぐな矩形を返す.
723        /// </summary>
724        /// <param name="points">CvPointの列挙子(CvPoint[], List&lt;CvPoint&gt;など). 内部でCvSeqに変換される.</param>
725        /// <returns>矩形</returns>
726        public static CvRect BoundingRect(IEnumerable<CvPoint> points)
727        {
728            if (points == null)
729            {
730                throw new ArgumentNullException("points");
731            }
732            CvRect result = new CvRect();
733            try  // ちょっと自信がないのでtryにしておく
734            {
735                using (CvMemStorage storage = new CvMemStorage(0))
736                {
737                    CvSeq<CvPoint> seq = new CvSeq<CvPoint>(SeqType.EltypePoint, CvSeq<CvPoint>.SizeOf, storage);
738                    foreach (CvPoint p in points)
739                    {
740                        SeqPush<CvPoint>(seq, p);
741                    }
742                    result = CvDll.cvBoundingRect(seq.CvPtr, false);
743                }
744            }
745            finally { }
746            return result;
747        }
748        #endregion
749        #region BoxPoints
750#if LANG_JA
751        /// <summary>
752        /// 箱の頂点を見つける
753        /// </summary>
754        /// <param name="box">箱</param>
755        /// <param name="pt">頂点の配列</param>
756#else
757        /// <summary>
758        /// Finds box vertices
759        /// </summary>
760        /// <param name="box">Box</param>
761        /// <param name="pt">Array of vertices</param>
762#endif
763        public static void BoxPoints(this CvBox2D box, out CvPoint2D32f[] pt)
764        {
765            pt = new CvPoint2D32f[4];
766            CvDll.cvBoxPoints(box, pt);
767        }
768        #endregion
769        #region CalcArrHist
770        /// <summary>
771        /// 1つの配列のヒストグラムを計算する.
772        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
773        /// </summary>
774        /// <param name="arr">入力配列</param>
775        /// <param name="hist">ヒストグラムへの参照</param>
776        public static void CalcArrHist(CvArr arr, CvHistogram hist)
777        {
778            CalcArrHist(arr, hist, false, null);
779        }
780        /// <summary>
781        /// 1つの配列のヒストグラムを計算する.
782        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
783        /// </summary>
784        /// <param name="arr">入力配列</param>
785        /// <param name="hist">ヒストグラムへの参照</param>
786        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない.</param>
787        public static void CalcArrHist(CvArr arr, CvHistogram hist, bool accumulate)
788        {
789            CalcArrHist(arr, hist, accumulate, null);
790        }
791        /// <summary>
792        /// 1つの配列のヒストグラムを計算する.
793        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
794        /// </summary>
795        /// <param name="arr">入力配列</param>
796        /// <param name="hist">ヒストグラムへの参照</param>
797        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない.</param>
798        /// <param name="mask">処理マスク.入力画像中のどのピクセルをカウントするかを決定する.</param>
799        public static void CalcArrHist(CvArr arr, CvHistogram hist, bool accumulate, CvArr mask)
800        {
801            if (arr == null)
802                throw new ArgumentNullException("arr");
803            if (hist == null)
804                throw new ArgumentNullException("hist");
805            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
806            CvDll.cvCalcArrHist(new IntPtr[] { arr.CvPtr }, hist.CvPtr, accumulate, maskPtr);
807        }
808        /// <summary>
809        /// 配列群のヒストグラムを計算する.
810        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
811        /// </summary>
812        /// <param name="arr">入力配列群.全て同じサイズ・タイプ.</param>
813        /// <param name="hist">ヒストグラムへの参照</param>
814        public static void CalcArrHist(CvArr[] arr, CvHistogram hist)
815        {
816            CalcArrHist(arr, hist, false, null);
817        }
818        /// <summary>
819        /// 配列群のヒストグラムを計算する.
820        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
821        /// </summary>
822        /// <param name="arr">入力配列群.全て同じサイズ・タイプ.</param>
823        /// <param name="hist">ヒストグラムへの参照</param>
824        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない. </param>
825        public static void CalcArrHist(CvArr[] arr, CvHistogram hist, bool accumulate)
826        {
827            CalcArrHist(arr, hist, accumulate, null);
828        }
829        /// <summary>
830        /// 配列群のヒストグラムを計算する.
831        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
832        /// </summary>
833        /// <param name="arr">入力配列群.全て同じサイズ・タイプ.</param>
834        /// <param name="hist">ヒストグラムへの参照</param>
835        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない. </param>
836        /// <param name="mask">処理マスク.入力画像中のどのピクセルをカウントするかを決定する.</param>
837        public static void CalcArrHist(CvArr[] arr, CvHistogram hist, bool accumulate, CvArr mask)
838        {
839            if (arr == null)
840                throw new ArgumentNullException("arr");
841            if (hist == null)
842                throw new ArgumentNullException("hist");
843            IntPtr[] arrPtr = new IntPtr[arr.Length];
844            for (int i = 0; i < arr.Length; i++)
845            {
846                arrPtr[i] = arr[i].CvPtr;
847            }
848            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
849            CvDll.cvCalcArrHist(arrPtr, hist.CvPtr, accumulate, maskPtr);
850        }
851        #endregion
852        #region CalcBackProject
853#if LANG_JA
854        /// <summary>
855        /// バックプロジェクションの計算を行う
856        /// </summary>
857        /// <param name="image">入力画像群</param>
858        /// <param name="back_project">出力のバックプロジェクション画像.入力画像群と同じタイプ.</param>
859        /// <param name="hist">ヒストグラム</param>
860        /// <returns></returns>
861#else
862        /// <summary>
863        /// Calculates back projection
864        /// </summary>
865        /// <param name="image">Source images (though you may pass CvMat** as well), all are of the same size and type </param>
866        /// <param name="back_project">Destination back projection image of the same type as the source images. </param>
867        /// <param name="hist">Histogram. </param>
868        /// <returns></returns>
869#endif
870        public static void CalcBackProject(CvArr[] image, CvArr back_project, CvHistogram hist )
871        {
872            if (image == null)
873            {
874                throw new ArgumentNullException("image");
875            }
876            if (back_project == null)
877            {
878                throw new ArgumentNullException("back_project");
879            }
880            if (hist == null)
881            {
882                throw new ArgumentNullException("hist");
883            }
884            IntPtr[] image_ptr = new IntPtr[image.Length];
885            for(int i =0;i<image.Length;i++){
886            image_ptr[i]=image[i].CvPtr;
887            }
888            CvDll.cvCalcBackProject(image_ptr, back_project.CvPtr, hist.CvPtr);
889        }
890        #endregion
891        #region CalcBackProjectPatch
892#if LANG_JA
893        /// <summary>
894        /// ヒストグラムの比較に基づき画像内部でのテンプレート位置を求める
895        /// </summary>
896        /// <param name="image">入力画像群( CvMat** 形式でも構わない).すべて同じサイズ.</param>
897        /// <param name="dst">出力画像</param>
898        /// <param name="patch_size">入力画像群上をスライドさせるテンプレートのサイズ</param>
899        /// <param name="hist">テンプレートのヒストグラム</param>
900        /// <param name="method">比較方法.値は関数 cvCompareHist に渡される(この関数に関する記述を参照)</param>
901        /// <returns></returns>
902#else
903        /// <summary>
904        /// Locates a template within image by histogram comparison
905        /// </summary>
906        /// <param name="image">Source images (though you may pass CvMat** as well), all are of the same size and type </param>
907        /// <param name="dst">Destination image. </param>
908        /// <param name="patch_size">Size of patch slid though the source images. </param>
909        /// <param name="hist">Histogram. </param>
910        /// <param name="method">Compasion method, passed to cvCompareHist (see description of that function). </param>
911        /// <returns></returns>
912#endif
913        public static void CalcBackProjectPatch(CvArr[] image, CvArr dst, CvSize patch_size, CvHistogram hist, HistogramComparison method)
914        {
915            if (image == null)
916            {
917                throw new ArgumentNullException("image");
918            }
919            if (dst == null)
920            {
921                throw new ArgumentNullException("dst");
922            }
923            if (hist == null)
924            {
925                throw new ArgumentNullException("hist");
926            }
927            IntPtr[] image_ptr = new IntPtr[image.Length];
928            for (int i = 0; i < image.Length; i++)
929            {
930                image_ptr[i] = image[i].CvPtr;
931            }
932            CvDll.cvCalcBackProjectPatch(image_ptr, dst.CvPtr, patch_size, hist.CvPtr, (int)method, 1f);
933        }
934#if LANG_JA
935        /// <summary>
936        /// ヒストグラムの比較に基づき画像内部でのテンプレート位置を求める
937        /// </summary>
938        /// <param name="image">入力画像群( CvMat** 形式でも構わない).すべて同じサイズ.</param>
939        /// <param name="dst">出力画像</param>
940        /// <param name="patch_size">入力画像群上をスライドさせるテンプレートのサイズ</param>
941        /// <param name="hist">テンプレートのヒストグラム</param>
942        /// <param name="method">比較方法.値は関数 cvCompareHist に渡される(この関数に関する記述を参照)</param>
943        /// <param name="factor">ヒストグラムの正規化係数.出力画像の正規化スケールに影響する.値に確信がない場合は,1にする.</param>
944        /// <returns></returns>
945#else
946        /// <summary>
947        /// Locates a template within image by histogram comparison
948        /// </summary>
949        /// <param name="image">Source images (though you may pass CvMat** as well), all are of the same size and type </param>
950        /// <param name="dst">Destination image. </param>
951        /// <param name="patch_size">Size of patch slid though the source images. </param>
952        /// <param name="hist">Histogram. </param>
953        /// <param name="method">Compasion method, passed to cvCompareHist (see description of that function). </param>
954        /// <param name="factor">Normalization factor for histograms, will affect normalization scale of destination image, pass 1. if unsure. </param>
955        /// <returns></returns>
956#endif
957        public static void CalcBackProjectPatch(CvArr[] image, CvArr dst, CvSize patch_size, CvHistogram hist, HistogramComparison method, float factor )
958
959        {
960            if (image == null)
961            {
962                throw new ArgumentNullException("image");
963            }
964            if (dst == null)
965            {
966                throw new ArgumentNullException("dst");
967            }
968            if (hist == null)
969            {
970                throw new ArgumentNullException("hist");
971            }
972            IntPtr[] image_ptr = new IntPtr[image.Length];
973            for (int i = 0; i < image.Length; i++)
974            {
975                image_ptr[i] = image[i].CvPtr;
976            }
977            CvDll.cvCalcBackProjectPatch(image_ptr, dst.CvPtr,patch_size, hist.CvPtr,(int)method,factor);
978        }
979        #endregion
980        #region CalcCovarMatrix
981        /// <summary>
982        /// 1つの画像のヒストグラムを計算する.
983        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
984        /// </summary>
985        /// <param name="vects">入力ベクトル.これらはすべて同じタイプで同じサイズでなくてはならない.</param>
986        /// <param name="cov_mat">浮動小数点型の正方な出力共変動行列</param>
987        /// <param name="avg">入力または出力配列(フラグに依存する) - 入力ベクトルの平均ベクトル</param>
988        /// <param name="flags">操作フラグ</param>
989        public static void CalcCovarMatrix(CvArr[] vects, CvArr cov_mat, CvArr avg, CovarMatrixFlag flags)
990        {
991            if (vects == null)
992                throw new ArgumentNullException("vects");
993            if (cov_mat == null)
994                throw new ArgumentNullException("cov_mat");
995            if (avg == null)
996                throw new ArgumentNullException("avg");
997            IntPtr[] vectsPtr = new IntPtr[vects.Length];
998            for (int i = 0; i < vects.Length; i++)
999            {
1000                if (vects[i] == null)
1001                {
1002                    throw new ArgumentNullException(string.Format("vects[{0}]", i));
1003                }
1004                vectsPtr[i] = vects[i].CvPtr;
1005            }
1006            CvDll.cvCalcCovarMatrix(vectsPtr, vects.Length, cov_mat.CvPtr, avg.CvPtr, flags);
1007        }
1008        #endregion
1009        #region CalcHist
1010        /// <summary>
1011        /// 1つの画像のヒストグラムを計算する.
1012        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
1013        /// </summary>
1014        /// <param name="image">入力画像</param>
1015        /// <param name="hist">ヒストグラムへの参照</param>
1016        public static void CalcHist(IplImage image, CvHistogram hist)
1017        {
1018            CalcArrHist(image, hist);
1019        }
1020        /// <summary>
1021        /// 1つの画像のヒストグラムを計算する.
1022        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
1023        /// </summary>
1024        /// <param name="image">入力画像</param>
1025        /// <param name="hist">ヒストグラムへの参照</param>
1026        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない. </param>
1027        public static void CalcHist(IplImage image, CvHistogram hist, bool accumulate)
1028        {
1029            CalcArrHist(image, hist, accumulate);
1030        }
1031        /// <summary>
1032        /// 1つの画像のヒストグラムを計算する.
1033        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
1034        /// </summary>
1035        /// <param name="image">入力画像</param>
1036        /// <param name="hist">ヒストグラムへの参照</param>
1037        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない.</param>
1038        /// <param name="mask">処理マスク.入力画像中のどのピクセルをカウントするかを決定する.</param>
1039        public static void CalcHist(IplImage image, CvHistogram hist, bool accumulate, CvArr mask)
1040        {
1041            CalcArrHist(image, hist, accumulate, mask);
1042        }
1043        /// <summary>
1044        /// 画像群のヒストグラムを計算する.
1045        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
1046        /// </summary>
1047        /// <param name="image">入力画像群.全て同じサイズ・タイプ.</param>
1048        /// <param name="hist">ヒストグラムへの参照</param>
1049        public static void CalcHist(IplImage[] image, CvHistogram hist)
1050        {
1051            CalcArrHist(image, hist);
1052        }
1053        /// <summary>
1054        /// 画像群のヒストグラムを計算する.
1055        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
1056        /// </summary>
1057        /// <param name="image">入力画像群.全て同じサイズ・タイプ.</param>
1058        /// <param name="hist">ヒストグラムへの参照</param>
1059        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない. </param>
1060        public static void CalcHist(IplImage[] image, CvHistogram hist, bool accumulate)
1061        {
1062            CalcArrHist(image, hist, accumulate);
1063        }
1064        /// <summary>
1065        /// 画像群のヒストグラムを計算する.
1066        /// ヒストグラムのビンを増加(インクリメント)するために用いられるタプルの各要素は, 対応する入力画像群の同じ場所から取り出される.
1067        /// </summary>
1068        /// <param name="image">入力画像群.全て同じサイズ・タイプ.</param>
1069        /// <param name="hist">ヒストグラムへの参照</param>
1070        /// <param name="accumulate">計算フラグ.セットされている場合は,ヒストグラムは処理前には最初にクリアされない. </param>
1071        /// <param name="mask">処理マスク.入力画像中のどのピクセルをカウントするかを決定する.</param>
1072        public static void CalcHist(IplImage[] image, CvHistogram hist, bool accumulate, CvArr mask)
1073        {
1074            if (image == null)
1075                throw new ArgumentNullException("image");
1076            if (hist == null)
1077                throw new ArgumentNullException("hist");
1078            CalcArrHist(image, hist, accumulate, mask);
1079        }
1080        #endregion
1081        #region CalcOpticalFlowBM
1082        /// <summary>
1083        /// 重なり合ったblock_size.Width x block_size.Heightピクセルのブロック毎にオプティカルフローを計算する
1084        /// </summary>
1085        /// <param name="prev">1番目の画像,8 ビット,シングルチャンネル.</param>
1086        /// <param name="curr">2番目の画像,8 ビット,シングルチャンネル.</param>
1087        /// <param name="block_size">比較対象となる基本ブロックのサイズ. </param>
1088        /// <param name="shift_size">ブロック座標の増加量. </param>
1089        /// <param name="max_range">走査対象となるブロックの近傍領域.ピクセル単位.</param>
1090        /// <param name="use_previous">trueの場合、前の(入力)速度場を用いる. </param>
1091        /// <param name="velx">次ののオプティカルフローの水平成分. ceil(prev->width/block_size.width)×ceil(prev->height/block_size.height) のサイズ, 32 ビット浮動小数点型,シングルチャンネル. </param>
1092        /// <param name="vely">velx と同一サイズ,32 ビット浮動小数点型,シングルチャンネルのオプティカルフローの垂直成分.</param>
1093        public static void CalcOpticalFlowBM(CvArr prev, CvArr curr, CvSize block_size, CvSize shift_size, CvSize max_range, bool use_previous, CvArr velx, CvArr vely)
1094        {
1095            if (prev == null)
1096                throw new ArgumentNullException("prev");
1097            if (curr == null)
1098                throw new ArgumentNullException("curr");
1099            if (velx == null)
1100                throw new ArgumentNullException("velx");
1101            if (vely == null)
1102                throw new ArgumentNullException("vely");
1103            CvDll.cvCalcOpticalFlowBM(prev.CvPtr, curr.CvPtr, block_size, shift_size, max_range, use_previous, velx.CvPtr, vely.CvPtr);
1104        }
1105        #endregion
1106        #region CalcOpticalFlowHS
1107        /// <summary>
1108        /// Horn &amp; Schunck アルゴリズムを用いて,1番目の入力画像の全ピクセルに対するフローを,2番目の画像を参照して計算する.
1109        /// </summary>
1110        /// <param name="prev">1番目の画像,8 ビット,シングルチャンネル.</param>
1111        /// <param name="curr">2番目の画像,8 ビット,シングルチャンネル.</param>
1112        /// <param name="use_previous">trueの場合、前の(入力)速度場を用いる.</param>
1113        /// <param name="velx">入力画像と同じサイズのオプティカルフローの水平成分,32 ビット浮動小数点型,シングルチャンネル.</param>
1114        /// <param name="vely">入力画像と同じサイズのオプティカルフローの垂直成分,32 ビット浮動小数点型,シングルチャンネル.</param>
1115        /// <param name="lambda">ラグランジュ乗数</param>
1116        /// <param name="criteria">速度計算の終了条件</param>   
1117        public static void CalcOpticalFlowHS(CvArr prev, CvArr curr, bool use_previous, CvArr velx, CvArr vely, double lambda, CvTermCriteria criteria)
1118        {
1119            if (prev == null)
1120                throw new ArgumentNullException("prev");
1121            if (curr == null)
1122                throw new ArgumentNullException("curr");
1123            if (velx == null)
1124                throw new ArgumentNullException("velx");
1125            if (vely == null)
1126                throw new ArgumentNullException("vely");
1127            CvDll.cvCalcOpticalFlowHS(prev.CvPtr, curr.CvPtr, use_previous, velx.CvPtr, vely.CvPtr, lambda, criteria);
1128        }
1129        #endregion
1130        #region CalcOpticalFlowLK
1131        /// <summary>
1132        /// Lucas &amp; Kanade アルゴリズムを用いて,1番目の入力画像の全ピクセルに対するフローを,2番目の画像を参照して計算する.
1133        /// </summary>
1134        /// <param name="prev">1番目の画像,8 ビット,シングルチャンネル.</param>
1135        /// <param name="curr">2番目の画像,8 ビット,シングルチャンネル.</param>
1136        /// <param name="win_size">ピクセルをグループ化するために用いられる平均化ウィンドウのサイズ</param>
1137        /// <param name="velx">入力画像と同じサイズのオプティカルフローの水平成分,32 ビット浮動小数点型,シングルチャンネル.</param>
1138        /// <param name="vely">入力画像と同じサイズのオプティカルフローの垂直成分,32 ビット浮動小数点型,シングルチャンネル.</param>       
1139        public static void CalcOpticalFlowLK(CvArr prev, CvArr curr, CvSize win_size, CvArr velx, CvArr vely)
1140        {
1141            if (prev == null)
1142                throw new ArgumentNullException("prev");
1143            if (curr == null)
1144                throw new ArgumentNullException("curr");
1145            if (velx == null)
1146                throw new ArgumentNullException("velx");
1147            if (vely == null)
1148                throw new ArgumentNullException("vely");
1149            CvDll.cvCalcOpticalFlowLK(prev.CvPtr, curr.CvPtr, win_size, velx.CvPtr, vely.CvPtr);
1150        }
1151        #endregion
1152        #region CalcOpticalFlowPyrLK
1153        /// <summary>
1154        ///  Lucas-Kanade オプティカルフローの, ピラミッドを用いて疎な特徴に対応した反復バージョン([Bouguet00])の実装である.
1155        /// 前フレームにおける特徴点の座標が与えられた場合に,現在のフレームにおける特徴点の座標が計算される.座標はサブピクセル精度で検出される.
1156        /// </summary>
1157        /// <param name="prev">1番目のフレーム(時間 t)</param>
1158        /// <param name="curr">2番目のフレーム(時間 t + dt)</param>
1159        /// <param name="prev_pyr">最初の画像に対するピラミッドのバッファ.これが NULL でない場合は,このバッファは,レベル 1 からレベル#level までのピラミッドを格納するのに十分なサイズでなければならない. (image_width+8)*image_height/3 バイトの合計が十分なサイズとなる.</param>
1160        /// <param name="curr_pyr">prev_pyr と同様に,2番目のフレームに対して用いられる</param>
1161        /// <param name="prev_features">フローを検出するのに必要な点の配列</param>
1162        /// <param name="curr_features">2次元の点の配列.2番目の画像(フレーム)中の入力特徴の新たな位置が計算され,ここに格納される</param>
1163        /// <param name="win_size">各ピラミッドレベルでの探索ウィンドウのサイズ</param>
1164        /// <param name="level">ピラミッドレベルの最大値.0 の場合はピラミッドは用いられない(シングルレベル).1 の場合はレベル 2 となる.</param>
1165        /// <param name="status">配列.特徴に対応するフローが見つかった場合に,配列の各要素 が 1 にセットされる.そうでない場合は0 になる.</param>       
1166        /// <param name="track_error">移動前の点と移動後の点の周辺領域の差(誤差)を含む倍精度型の配列.オプションパラメータ(NULL も取りうる).</param> 
1167        /// <param name="criteria">各ピラミッドの各点に対するフローを検出する繰り返し計算の終了条件</param>
1168        /// <param name="flags">雑多なフラグ</param> 
1169        public static void CalcOpticalFlowPyrLK(CvArr prev, CvArr curr, CvArr prev_pyr, CvArr curr_pyr, CvPoint2D32f[] prev_features, out CvPoint2D32f[] curr_features,
1170            CvSize win_size, int level, out byte[] status, out float[] track_error, CvTermCriteria criteria, LKFlowFlag flags)
1171        {
1172            if (prev == null)
1173                throw new ArgumentNullException("prev");
1174            if (curr == null)
1175                throw new ArgumentNullException("curr");
1176            if (prev_pyr == null)
1177                throw new ArgumentNullException("prev_pyr");
1178            if (curr_pyr == null)
1179                throw new ArgumentNullException("curr_pyr");
1180            if (prev_features == null)
1181                throw new ArgumentNullException("prev_features");
1182
1183            curr_features = new CvPoint2D32f[prev_features.Length];
1184            status = new byte[prev_features.Length];
1185            track_error = new float[prev_features.Length];
1186
1187            CvDll.cvCalcOpticalFlowPyrLK(prev.CvPtr, curr.CvPtr, prev_pyr.CvPtr, curr_pyr.CvPtr, prev_features, curr_features, prev_features.Length, win_size, level, status, track_error, criteria, flags);
1188        }
1189        #endregion
1190        #region CalcPCA
1191#if LANG_JA
1192/// <summary>
1193        ///
1194        /// </summary>
1195        /// <param name="data"></param>
1196        /// <param name="avg"></param>
1197        /// <param name="eigenvalues"></param>
1198        /// <param name="eigenvectors"></param>
1199        /// <param name="flags"></param>
1200        /// <returns></returns>
1201#else
1202        /// <summary>
1203        /// Performs Principal Component Analysis of a vector set
1204        /// </summary>
1205        /// <param name="data">The input data; each vector is either a single row (CV_PCA_DATA_AS_ROW) or a single column (CV_PCA_DATA_AS_COL).  </param>
1206        /// <param name="avg">The mean (average) vector, computed inside the function or provided by user. </param>
1207        /// <param name="eigenvalues">The output eigenvalues of covariation matrix. </param>
1208        /// <param name="eigenvectors">The output eigenvectors of covariation matrix (i.e. principal components); one vector per row. </param>
1209        /// <param name="flags">The operation flags</param>
1210        /// <returns></returns>
1211
1212#endif
1213        public static void CalcPCA(CvArr data, CvArr avg,CvArr eigenvalues, CvArr eigenvectors, PCAFlag flags )
1214        {
1215            if (data == null)
1216            {
1217                throw new ArgumentNullException("data");
1218            }
1219            if (avg == null)
1220            {
1221                throw new ArgumentNullException("avg");
1222            }
1223            CvDll.cvCalcPCA(data.CvPtr, avg.CvPtr, eigenvalues.CvPtr,eigenvectors.CvPtr,flags);
1224        }
1225        #endregion
1226        #region CalcProbDensity
1227        /// <summary>
1228        /// 一つのヒストグラムをもう一方のヒストグラムで割る
1229        /// </summary>
1230        /// <param name="hist1">一番目のヒストグラム(除数)</param>
1231        /// <param name="hist2">二番目のヒストグラム</param>
1232        /// <param name="dst_hist">出力ヒストグラム</param>
1233        public static void CalcProbDensity(CvHistogram hist1, CvHistogram hist2, CvHistogram dst_hist)
1234        {
1235            CalcProbDensity(hist1, hist2, dst_hist, 255);
1236        }
1237        /// <summary>
1238        /// 一つのヒストグラムをもう一方のヒストグラムで割る
1239        /// </summary>
1240        /// <param name="hist1">一番目のヒストグラム(除数)</param>
1241        /// <param name="hist2">二番目のヒストグラム</param>
1242        /// <param name="dst_hist">出力ヒストグラム</param>
1243        /// <param name="scale">出力ヒストグラムのスケール係数</param>
1244        public static void CalcProbDensity(CvHistogram hist1, CvHistogram hist2, CvHistogram dst_hist, double scale)
1245        {
1246            if (hist1 == null)
1247                throw new ArgumentNullException("hist1");
1248            if (hist2 == null)
1249                throw new ArgumentNullException("hist2");
1250            if (dst_hist == null)
1251                throw new ArgumentNullException("dst_hist");
1252            CvDll.cvCalcProbDensity(hist1.CvPtr, hist2.CvPtr, dst_hist.CvPtr, scale);
1253        }
1254        #endregion
1255        #region CalcSubdivVoronoi2D
1256        /// <summary>
1257        /// 仮想点の座標を計算する.元の細分割面のある頂点に対応する仮想点全てを接続すると,その頂点を含むボロノイ領域の境界を構成する.
1258        /// </summary>
1259        /// <param name="subdiv">ドロネー細分割.全ての点は追加済みである</param>
1260        public static void CalcSubdivVoronoi2D(CvSubdiv2D subdiv)
1261        {
1262            if (subdiv == null)
1263            {
1264                throw new ArgumentNullException("subdiv");
1265            }
1266            CvDll.cvCalcSubdivVoronoi2D(subdiv.CvPtr);
1267        }
1268        #endregion
1269        #region CalibrateCamera2
1270        /// <summary>
1271        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1272        /// </summary>
1273        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1274        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1275        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1276        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1277        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1278        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1279        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, out CvMat intrinsic_matrix, out CvMat distortion_coeffs)
1280        {
1281            CvMat rotation_vectors, translation_vectors;
1282            intrinsic_matrix = new CvMat(3, 3, MatrixType.F32C1);
1283            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, CalibrateCameraFlag.Default);
1284        }
1285        /// <summary>
1286        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1287        /// </summary>
1288        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1289        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1290        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1291        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1292        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1293        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1294        /// <param name="rotation_vectors">出力される3xMの回転ベクトルの配列 (コンパクトな回転行列の表記についてはcvRodrigues2を参照).</param>
1295        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, out CvMat intrinsic_matrix, out CvMat distortion_coeffs, out CvMat rotation_vectors)
1296        {
1297            CvMat translation_vectors;
1298            intrinsic_matrix = new CvMat(3, 3, MatrixType.F32C1);
1299            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, CalibrateCameraFlag.Default);
1300        }
1301        /// <summary>
1302        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1303        /// </summary>
1304        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1305        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1306        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1307        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1308        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1309        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1310        /// <param name="rotation_vectors">出力される3xMの回転ベクトルの配列 (コンパクトな回転行列の表記についてはcvRodrigues2を参照).</param>
1311        /// <param name="translation_vectors">出力される3xMの並進ベクトルの配列.</param>
1312        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, out CvMat intrinsic_matrix, out CvMat distortion_coeffs, out CvMat rotation_vectors, out CvMat translation_vectors)
1313        {
1314            intrinsic_matrix = new CvMat(3, 3, MatrixType.F32C1);
1315            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, CalibrateCameraFlag.Default);
1316        }
1317        /// <summary>
1318        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1319        /// </summary>
1320        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1321        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1322        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1323        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1324        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1325        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1326        /// <param name="rotation_vectors">出力される3xMの回転ベクトルの配列 (コンパクトな回転行列の表記についてはcvRodrigues2を参照).</param>
1327        /// <param name="translation_vectors">出力される3xMの並進ベクトルの配列.</param>
1328        /// <param name="flags">処理フラグ</param>
1329        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, out CvMat intrinsic_matrix, out CvMat distortion_coeffs, out CvMat rotation_vectors, out CvMat translation_vectors, CalibrateCameraFlag flags)
1330        {
1331            intrinsic_matrix = new CvMat(3, 3, MatrixType.F32C1);
1332            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, flags);
1333        }
1334        /// <summary>
1335        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1336        /// </summary>
1337        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1338        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1339        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1340        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1341        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1342        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1343        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, CvMat intrinsic_matrix, out CvMat distortion_coeffs)
1344        {
1345            CvMat rotation_vectors;
1346            CvMat translation_vectors;
1347            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, CalibrateCameraFlag.Default);
1348        }
1349        /// <summary>
1350        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1351        /// </summary>
1352        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1353        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1354        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1355        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1356        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1357        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1358        /// <param name="rotation_vectors">出力される3xMの回転ベクトルの配列 (コンパクトな回転行列の表記についてはcvRodrigues2を参照).</param>
1359        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, CvMat intrinsic_matrix, out CvMat distortion_coeffs, out CvMat rotation_vectors)
1360        {
1361            CvMat translation_vectors;
1362            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, CalibrateCameraFlag.Default);
1363        }
1364        /// <summary>
1365        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1366        /// </summary>
1367        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1368        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1369        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1370        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1371        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1372        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1373        /// <param name="rotation_vectors">出力される3xMの回転ベクトルの配列 (コンパクトな回転行列の表記についてはcvRodrigues2を参照).</param>
1374        /// <param name="translation_vectors">出力される3xMの並進ベクトルの配列.</param>
1375        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, CvMat intrinsic_matrix, out CvMat distortion_coeffs, out CvMat rotation_vectors, out CvMat translation_vectors)
1376        {
1377            CalibrateCamera2(object_points, image_points, point_counts, image_size, intrinsic_matrix, out distortion_coeffs, out rotation_vectors, out translation_vectors, CalibrateCameraFlag.Default);
1378        }
1379        /// <summary>
1380        /// 内部パラメータと各画像に対する 外部パラメータを推定する.
1381        /// </summary>
1382        /// <param name="object_points">オブジェクト(キャリブレーションパターン)上の点群座標の結合行列.3xN または Nx3の配列.Nはすべてのビューでの点の数の合計である.</param>
1383        /// <param name="image_points">対応する画像上の点群座標の結合行列. 2xN またはNx2 の配列.Nはすべてのビューでの点の数の合計である.</param>
1384        /// <param name="point_counts">それぞれのビューに含まれる点の数を表すベクトル.サ イズは 1xM または Mx1 でMはビューの数.1xM or Mx1</param>
1385        /// <param name="image_size">画像サイズ.内部カメラ行列の初期化のみに用いられる.</param>
1386        /// <param name="intrinsic_matrix">出力されるカメラ行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. CV_CALIB_USE_INTRINSIC_GUESS  や CV_CALIB_FIX_ASPECT_RATION が指定され た場合,fx, fy, cx, cyのパラメータのうち いくつか,またはすべてを初期化する必要がある.</param>
1387        /// <param name="distortion_coeffs">出力される1x4のひずみ係数ベクトル [k1, k2, p1, p2]. </param>
1388        /// <param name="rotation_vectors">出力される3xMの回転ベクトルの配列 (コンパクトな回転行列の表記についてはcvRodrigues2を参照).</param>
1389        /// <param name="translation_vectors">出力される3xMの並進ベクトルの配列.</param>
1390        /// <param name="flags">処理フラグ</param>
1391        public static void CalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, CvSize image_size, CvMat intrinsic_matrix, out CvMat distortion_coeffs, out CvMat rotation_vectors, out CvMat translation_vectors, CalibrateCameraFlag flags)
1392        {
1393            if (object_points == null)
1394                throw new ArgumentNullException("object_points");
1395            if (image_points == null)
1396                throw new ArgumentNullException("image_points");
1397            if (point_counts == null)
1398                throw new ArgumentNullException("point_counts");
1399            int m = Math.Max(point_counts.Rows, point_counts.Cols);
1400            if (m <= 1)
1401            {
1402                throw new ArgumentException("point_countsの形式が不正です.");
1403            }
1404            IntPtr distortion_coeffs_ptr = CvDll.cvCreateMat(1, 4, MatrixType.F32C1);
1405            IntPtr rotation_vectors_ptr = CvDll.cvCreateMat(3, m, MatrixType.F32C1);
1406            IntPtr translation_vectors_ptr = CvDll.cvCreateMat(3, m, MatrixType.F32C1);
1407            CvDll.cvCalibrateCamera2(object_points.CvPtr, image_points.CvPtr, point_counts.CvPtr, image_size, intrinsic_matrix.CvPtr, distortion_coeffs_ptr, rotation_vectors_ptr, translation_vectors_ptr, flags);
1408            distortion_coeffs = new CvMat(distortion_coeffs_ptr, true);
1409            rotation_vectors = new CvMat(rotation_vectors_ptr, true);
1410            translation_vectors = new CvMat(rotation_vectors_ptr, true);
1411        }
1412        #endregion
1413        #region CamShift
1414#if LANG_JA
1415/// <summary>
1416        ///
1417        /// </summary>
1418         /// <param name="prob_image"></param>
1419        /// <param name="window"></param>
1420        /// <param name="criteria"></param>
1421        /// <param name="comp"></param>
1422        /// <returns></returns>
1423#else
1424        /// <summary>
1425        /// Finds object center, size, and orientation
1426        /// </summary>
1427        /// <param name="prob_image">Back projection of object histogram (see cvCalcBackProject). </param>
1428        /// <param name="window">Initial search window. </param>
1429        /// <param name="criteria">Criteria applied to determine when the window search should be finished. </param>
1430        /// <param name="comp">Resultant structure that contains converged search window coordinates (comp->rect field) and sum of all pixels inside the window (comp->area field). </param>
1431        /// <returns>The function returns number of iterations made within cvMeanShift. </returns>
1432
1433#endif
1434        public static int CamShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, CvConnectedComp comp)
1435        {
1436            return CamShift(prob_image, window, criteria, comp, null);
1437        }
1438#if LANG_JA
1439/// <summary>
1440        ///
1441        /// </summary>
1442         /// <param name="prob_image"></param>
1443        /// <param name="window"></param>
1444        /// <param name="criteria"></param>
1445        /// <param name="comp"></param>
1446        /// <param name="box"></param>
1447
1448        /// <returns></returns>
1449#else
1450        /// <summary>
1451        /// Finds object center, size, and orientation
1452        /// </summary>
1453        /// <param name="prob_image">Back projection of object histogram (see cvCalcBackProject). </param>
1454        /// <param name="window">Initial search window. </param>
1455        /// <param name="criteria">Criteria applied to determine when the window search should be finished. </param>
1456        /// <param name="comp">Resultant structure that contains converged search window coordinates (comp->rect field) and sum of all pixels inside the window (comp->area field). </param>
1457        /// <param name="box">Circumscribed box for the object. If not NULL, contains object size and orientation. </param>
1458        /// <returns>The function returns number of iterations made within cvMeanShift. </returns>
1459
1460#endif
1461        public static int CamShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, CvConnectedComp comp, CvBox2D box)
1462        {
1463            if (prob_image == null)
1464            {
1465                throw new ArgumentNullException("prob_image");
1466            }
1467            if (comp == null)
1468            {
1469                throw new ArgumentNullException("comp");
1470            }
1471            return CvDll.cvCamShift(prob_image.CvPtr, window, criteria, comp.CvPtr, box);
1472        }
1473        #endregion
1474        #region Canny
1475        /// <summary>
1476        /// Cannyアルゴリズムを使用して,入力画像 imageに含まれているエッジを検出し,それを出力画像 edges に保存する [aperture_size=3].
1477        /// threshold1 と threshold2 のうち小さいほうがエッジ同士を接続するために用いられ,大きいほうが強いエッジの初期検出に用いられる.
1478        /// </summary>
1479        /// <param name="image">入力画像</param>
1480        /// <param name="edges">この関数によって得られたエッジ画像</param>
1481        /// <param name="threshold1">1番目の閾値</param>
1482        /// <param name="threshold2">2番目の閾値</param>
1483        public static void Canny(this CvArr image, CvArr edges, double threshold1, double threshold2)
1484        {
1485            Canny(image, edges, threshold1, threshold2, ApertureSize.Size3);
1486        }
1487        /// <summary>
1488        /// Cannyアルゴリズムを使用して,入力画像 imageに含まれているエッジを検出し,それを出力画像 edges に保存する.
1489        /// threshold1 と threshold2 のうち小さいほうがエッジ同士を接続するために用いられ,大きいほうが強いエッジの初期検出に用いられる.
1490        /// </summary>
1491        /// <param name="image">入力画像</param>
1492        /// <param name="edges">この関数によって得られたエッジ画像</param>
1493        /// <param name="threshold1">1番目の閾値</param>
1494        /// <param name="threshold2">2番目の閾値</param>
1495        /// <param name="aperture_size">Sobel演算子のアパーチャサイズ</param>
1496        public static void Canny(this CvArr image, CvArr edges, double threshold1, double threshold2, ApertureSize aperture_size)
1497        {
1498            if (image == null)
1499                throw new ArgumentNullException();
1500            if (edges == null)
1501                throw new ArgumentNullException();
1502            CvDll.cvCanny(image.CvPtr, edges.CvPtr, threshold1, threshold2, aperture_size);
1503        }
1504        #endregion
1505        #region Cbrt
1506        /// <summary>
1507        /// 数の立方根を計算する.
1508        /// これは,通常,pow(value,1./3)を計算するよりも高速である.一方,負の引数も正しく処理される.
1509        /// また,特別な値(±Inf, NaN)は扱うことができない.
1510        /// </summary>
1511        /// <param name="value">浮動小数点型の入力値</param>
1512        /// <returns></returns>
1513        public static float Cbrt(float value)
1514        {
1515            return CvDll.cvCbrt(value);
1516        }
1517        #endregion
1518        #region Ceil
1519        /// <summary>
1520        /// 引数より小さくない最小の整数値を返す.
1521        /// いくつかのアーキテクチャにおいて,これらの関数はC言語の標準的なキャスト演算よりも非常に高速である.
1522        /// 引数の絶対値が2^31より大きい場合,結果は求まらない.また,特別な値(±Inf, NaN)は扱うことができない.
1523        /// </summary>
1524        /// <param name="value">浮動小数点型の入力値</param>
1525        /// <returns></returns>
1526        public static int Ceil(double value)
1527        {
1528            return CvInline.cvCeil(value);
1529        }
1530        #endregion
1531        #region CheckArr
1532        /// <summary>
1533        /// 入力配列のすべての要素について,無効な値が存在しないかをチェックする
1534        /// </summary>
1535        /// <param name="arr">チェック対象の配列</param>
1536        /// <returns>チェックが正しく終わればtrue</returns>
1537        public static bool CheckArr(this CvArr arr)
1538        {
1539
1540            return CheckArr(arr, CheckArrFlag.NanOrInfinity);
1541        }
1542        /// <summary>
1543        /// 入力配列のすべての要素について,無効な値が存在しないかをチェックする
1544        /// </summary>
1545        /// <param name="arr">チェック対象の配列</param>
1546        /// <param name="flags">処理フラグ</param>
1547        /// <returns>チェックが正しく終わればtrue</returns>
1548        public static bool CheckArr(this CvArr arr, CheckArrFlag flags)
1549        {
1550            return CheckArr(arr, flags, 0, 0);
1551        }
1552        /// <summary>
1553        /// 入力配列のすべての要素について,無効な値が存在しないかをチェックする
1554        /// </summary>
1555        /// <param name="arr">チェック対象の配列</param>
1556        /// <param name="flags">処理フラグ</param>
1557        /// <param name="min_val">有効な値域の下限値(この値以上).CheckArrFlag.Range がセットされているときのみ有効.</param>
1558        /// <param name="max_val">有効な値域の上限値(この値未満).CheckArrFlag.Range がセットされているときのみ有効.</param>
1559        /// <returns>チェックが正しく終わればtrue</returns>
1560        public static bool CheckArr(this CvArr arr, CheckArrFlag flags, double min_val, double max_val)
1561        {
1562            if (arr == null)
1563            {
1564                throw new ArgumentNullException("arr");
1565            }
1566            return CvDll.cvCheckArr(arr.CvPtr, flags, min_val, max_val) != 0;
1567        }
1568        /// <summary>
1569        /// 入力配列のすべての要素について,無効な値が存在しないかをチェックする. CheckArrのエイリアス.
1570        /// </summary>
1571        /// <param name="arr">チェック対象の配列</param>
1572        /// <returns>チェックが正しく終わればtrue</returns>
1573        public static bool CheckArray(this CvArr arr)
1574        {
1575            return CheckArr(arr);
1576        }
1577        /// <summary>
1578        /// 入力配列のすべての要素について,無効な値が存在しないかをチェックする. CheckArrのエイリアス.
1579        /// </summary>
1580        /// <param name="arr">チェック対象の配列</param>
1581        /// <param name="flags">処理フラグ</param>
1582        /// <returns>チェックが正しく終わればtrue</returns>
1583        public static bool CheckArray(this CvArr arr, CheckArrFlag flags)
1584        {
1585            return CheckArr(arr, flags);
1586        }
1587        /// <summary>
1588        /// 入力配列のすべての要素について,無効な値が存在しないかをチェックする. CheckArrのエイリアス.
1589        /// </summary>
1590        /// <param name="arr">チェック対象の配列</param>
1591        /// <param name="flags">処理フラグ</param>
1592        /// <param name="min_val">有効な値域の下限値(この値以上).CheckArrFlag.Range がセットされているときのみ有効.</param>
1593        /// <param name="max_val">有効な値域の上限値(この値未満).CheckArrFlag.Range がセットされているときのみ有効.</param>
1594        /// <returns>チェックが正しく終わればtrue</returns>
1595        public static bool CheckArray(this CvArr arr, CheckArrFlag flags, double min_val, double max_val)
1596        {
1597            return CheckArr(arr, flags, min_val, max_val);
1598        }
1599        #endregion
1600        #region CheckContourConvexity
1601        /// <summary>
1602        /// 輪郭が凸であるかを調べる
1603        /// </summary>
1604        /// <param name="contour">テストする輪郭(点列のシーケンスか配列)</param>
1605        /// <returns></returns>
1606        public static bool CheckContourConvexity(this CvArr contour)
1607        {
1608            if (contour == null)
1609            {
1610                throw new ArgumentNullException("contour");
1611            }
1612            return CvDll.cvCheckContourConvexity(contour.CvPtr);
1613            //return CvDll.cvCheckContourConvexity(contour.CvPtr) != 0;
1614        }
1615        #endregion
1616        #region CheckTermCriteria
1617        /// <summary>
1618        /// 終了条件をチェックし,type= Iteration|Epsilon に設定し,反復数の max_iterとeprilon の両方が有効になるように変換する
1619        /// </summary>
1620        /// <param name="criteria"></param>
1621        /// <param name="default_eps"></param>
1622        /// <param name="default_max_iters"></param>
1623        /// <returns>変換結果</returns>
1624        public static CvTermCriteria CheckTermCriteria(this CvTermCriteria criteria, double default_eps, int default_max_iters)
1625        {
1626            return CvDll.cvCheckTermCriteria(criteria, default_eps, default_max_iters);
1627        }
1628        #endregion
1629        #region Circle
1630        /// <summary>
1631        /// 与えた中心と半径に応じて枠だけ,もしくは塗りつぶされた円を描く.描画される円はROIによって切り取られる.
1632        /// </summary>
1633        /// <param name="img">画像</param>
1634        /// <param name="center">円の中心</param>
1635        /// <param name="radius">円の半径</param>
1636        /// <param name="color">円の色</param>
1637        public static void Circle(this CvArr img, CvPoint center, int radius, CvColor color)
1638        {
1639            Circle(img, center, radius, color, 1, LineType.Link8, 0);
1640        }
1641        /// <summary>
1642        /// 与えた中心と半径に応じて枠だけ,もしくは塗りつぶされた円を描く.描画される円はROIによって切り取られる.
1643        /// </summary>
1644        /// <param name="img">画像</param>
1645        /// <param name="center">円の中心</param>
1646        /// <param name="radius">円の半径</param>
1647        /// <param name="color">円の色</param>
1648        /// <param name="thickness">線の幅.負の値を指定した場合は塗りつぶされる.</param>
1649        public static void Circle(this CvArr img, CvPoint center, int radius, CvColor color, int thickness)
1650        {
1651            Circle(img, center, radius, color, thickness, LineType.Link8, 0);
1652        }
1653        /// <summary>
1654        /// 与えた中心と半径に応じて枠だけ,もしくは塗りつぶされた円を描く.描画される円はROIによって切り取られる.
1655        /// </summary>
1656        /// <param name="img">画像</param>
1657        /// <param name="center">円の中心</param>
1658        /// <param name="radius">円の半径</param>
1659        /// <param name="color">円の色</param>
1660        /// <param name="thickness">線の幅.負の値を指定した場合は塗りつぶされる.</param>
1661        /// <param name="line_type">線の種類</param>
1662        public static void Circle(this CvArr img, CvPoint center, int radius, CvColor color, int thickness, LineType line_type)
1663        {
1664            Circle(img, center, radius, color, thickness, line_type, 0);
1665        }
1666        /// <summary>
1667        /// 与えた中心と半径に応じて枠だけ,もしくは塗りつぶされた円を描く.描画される円はROIによって切り取られる.
1668        /// </summary>
1669        /// <param name="img">画像</param>
1670        /// <param name="center">円の中心</param>
1671        /// <param name="radius">円の半径</param>
1672        /// <param name="color">円の色</param>
1673        /// <param name="thickness">線の幅.負の値を指定した場合は塗りつぶされる.</param>
1674        /// <param name="line_type">線の種類</param>
1675        /// <param name="shift">中心座標と半径の小数点以下の桁を表すビット数.</param>
1676        public static void Circle(this CvArr img, CvPoint center, int radius, CvColor color, int thickness, LineType line_type, int shift)
1677        {
1678            if (img == null)
1679            {
1680                throw new ArgumentNullException("img");
1681            }
1682            CvDll.cvCircle(img.CvPtr, center, radius, color, thickness, line_type, shift);
1683        }
1684        #endregion
1685        #region ClearHist
1686        /// <summary>
1687        /// ヒストグラムをクリアする.
1688        /// 密なヒストグラムの場合,全てのヒストグラムのビンを0にセットする, また疎なヒストグラムの場合は,すべてのヒストグラムのビンを削除する.
1689        /// </summary>
1690        /// <param name="hist">対象のヒストグラムへの参照</param>
1691        public static void ClearHist(CvHistogram hist)
1692        {
1693            if (hist == null)
1694            {
1695                throw new ArgumentNullException("hist");
1696            }
1697            CvDll.cvClearHist(hist.CvPtr);
1698        }
1699        #endregion
1700        #region ClearMemStorage
1701        /// <summary>
1702        /// ストレージの先頭(空き領域の境界)を,一番最初に戻す.
1703        /// この関数はメモリを解放しない.もしストレージが親を持つ場合,この関数は親に全てのブロックを返す.
1704        /// </summary>
1705        /// <param name="storage">対象のストレージへの参照</param>
1706        public static void ClearMemStorage(CvMemStorage storage)
1707        {
1708            if (storage == null)
1709            {
1710                throw new ArgumentNullException("storage");
1711            }
1712            CvDll.cvClearMemStorage(storage.CvPtr);
1713        }
1714        #endregion
1715        #region ClearND
1716        /// <summary>
1717        /// 密な配列と疎な配列の指定した要素をクリア(0にセット)する.要素が存在しなければ,この関数は何もしない.
1718        /// </summary>
1719        /// <param name="arr">入力配列</param>
1720        /// <param name="idx">要素のインデックスの配列(可変長引数)</param>
1721        public static void ClearND(this CvArr arr, params int[] idx)
1722        {
1723            if (arr == null)
1724                throw new ArgumentNullException("arr");
1725            if (idx == null)
1726                throw new ArgumentNullException("idx");
1727            CvDll.cvClearND(arr.CvPtr, idx);
1728        }
1729        #endregion
1730        #region ClearSeq
1731        /// <summary>
1732        /// 与えられたインデックスをもつ要素を削除する.
1733        /// インデックスが範囲外の場合,この関数はエラーを発生する.空のシーケンスから要素を削除しようとすることは,この状況の一例である.
1734        /// この関数は,近い側のシーケンスの端とindex 番目(これは削除されない)の位置の間に存在するシーケンス要素をシフトする事によって,要素を削除する.
1735        /// </summary>
1736        /// <param name="seq">シーケンス</param>
1737        public static void ClearSeq(CvSeq seq)
1738        {
1739            if (seq == null)
1740            {
1741                throw new ArgumentNullException("seq");
1742            }
1743            CvDll.cvClearSeq(seq.CvPtr);
1744        }
1745        #endregion
1746        #region ClearSubdivVoronoi2D
1747        /// <summary>
1748        /// 全ての仮想点を削除する.
1749        /// この関数の前回の呼出し後に細分割が変更された場合,この関数は cvCalcSubdivVoronoi2D の内部で呼ばれる.
1750        /// </summary>
1751        /// <param name="subdiv">ドロネー細分割</param>
1752        public static void ClearSubdivVoronoi2D(CvSubdiv2D subdiv)
1753        {
1754            if (subdiv == null)
1755            {
1756                throw new ArgumentNullException("subdiv");
1757            }
1758            CvDll.cvClearSubdivVoronoi2D(subdiv.CvPtr);
1759        }
1760        #endregion
1761        #region CloneImage
1762        /// <summary>
1763        /// ヘッダ,ROI,データを含む画像の完全なコピーを作成する.
1764        /// </summary>
1765        /// <param name="image">オリジナル画像</param>
1766        /// <returns>コピーされた画像</returns>
1767        public static IplImage CloneImage(IplImage image)
1768        {
1769            if (image == null)
1770            {
1771                throw new ArgumentNullException("image");
1772            }
1773            IntPtr ptr = CvDll.cvCloneImage(image.CvPtr);
1774            if (ptr == IntPtr.Zero)
1775            {
1776                throw new OpenCvSharpException("画像の複製の生成に失敗しました。");
1777            }
1778            return new IplImage(ptr);
1779        }
1780        #endregion
1781        #region CloneMat
1782        /// <summary>
1783        /// 入力行列のコピーを作成し返す
1784        /// </summary>
1785        /// <param name="mat">入力行列</param>
1786        /// <returns>コピーされた行列</returns>
1787        public static CvMat CloneMat(CvMat mat)
1788        {
1789            if (mat == null)
1790            {
1791                throw new ArgumentNullException("mat");
1792            }
1793            IntPtr ptr = CvDll.cvCloneMat(mat.CvPtr);
1794            return new CvMat(ptr);
1795        }
1796        #endregion
1797        #region CloneSeq
1798        /// <summary>
1799        /// 入力行列のコピーを作成し返す
1800        /// </summary>
1801        /// <param name="seq">シーケンス</param>
1802        /// <returns>コピーされたCvSeq</returns>
1803        public static CvSeq CloneSeq(CvSeq seq)
1804        {
1805            return CloneSeq(seq, null);
1806        }
1807        /// <summary>
1808        /// 入力行列のコピーを作成し返す
1809        /// </summary>
1810        /// <param name="seq">シーケンス</param>
1811        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ(もしデータがあれば)を保存する出力ストレージ. nullの場合,入力シーケンスに含まれるストレージを使用する.</param>
1812        /// <returns>コピーされたCvSeq</returns>
1813        public static CvSeq CloneSeq(CvSeq seq, CvMemStorage storage)
1814        {
1815            if (seq == null)
1816            {
1817                throw new ArgumentNullException("seq");
1818            }
1819            IntPtr storagePtr = (storage == null) ? IntPtr.Zero : storage.CvPtr;
1820            IntPtr ptr = CvInline.cvCloneSeq(seq.Ptr, storagePtr);
1821            if (ptr == IntPtr.Zero)
1822                return null;
1823            else
1824                return new CvSeq(ptr);
1825        }
1826        /// <summary>
1827        /// 入力行列のコピーを作成し返す
1828        /// </summary>
1829        /// <param name="seq">シーケンス</param>
1830        /// <returns>コピーされたCvSeq</returns>
1831        public static CvSeq<T> CloneSeq<T>(CvSeq<T> seq) where T : struct
1832        {
1833            return CloneSeq<T>(seq, null);
1834        }
1835        /// <summary>
1836        /// 入力行列のコピーを作成し返す
1837        /// </summary>
1838        /// <param name="seq">シーケンス</param>
1839        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ(もしデータがあれば)を保存する出力ストレージ. nullの場合,入力シーケンスに含まれるストレージを使用する.</param>
1840        /// <returns>コピーされたCvSeq</returns>
1841        public static CvSeq<T> CloneSeq<T>(CvSeq<T> seq, CvMemStorage storage) where T : struct
1842        {
1843            if (seq == null)
1844            {
1845                throw new ArgumentNullException("seq");
1846            }
1847            IntPtr storagePtr = (storage == null) ? IntPtr.Zero : storage.CvPtr;
1848            IntPtr ptr = CvInline.cvCloneSeq(seq.Ptr, storagePtr);
1849            if (ptr == IntPtr.Zero)
1850                return null;
1851            else
1852                return new CvSeq<T>(ptr);
1853        }
1854        #endregion
1855        #region Cmp
1856        /// <summary>
1857        /// 二つの配列の各要素ごとの比較を行う. 対応する要素を比較し,出力配列の値にセットする.
1858        /// dst(I) = src1(I) op src2(I) .
1859        /// 比較結果が真(TRUE)であれば dst(I) には 0xff(要素すべてのビットが 1 )をセットし,それ以外の場合(FALSE)であれば 0 をセットする.
1860        /// すべての配列(出力配列を除く)は同じタイプで,配列のサイズ(またはROIのサイズ)も同じでなければならない.
1861        /// </summary>
1862        /// <param name="src1">入力配列(シングルチャンネル)</param>
1863        /// <param name="src2">2番目の入力配列.どちらの入力配列もシングルチャンネルでなければならない.</param>
1864        /// <param name="dst">出力配列(タイプは 8u か 8s でないといけない)</param>
1865        /// <param name="cmp_op">比較方法を示すフラグ</param>
1866        public static void Cmp(CvArr src1, CvArr src2, CvArr dst, ArrComparison cmp_op)
1867        {
1868            if (src1 == null)
1869                throw new ArgumentNullException("src1");
1870            if (src2 == null)
1871                throw new ArgumentNullException("src2");
1872            if (dst == null)
1873                throw new ArgumentNullException("dst");
1874            CvDll.cvCmp(src1.CvPtr, src2.CvPtr, dst.CvPtr, cmp_op);
1875        }
1876        #endregion
1877        #region CmpS
1878        /// <summary>
1879        /// 配列要素とスカラーを比較し,出力配列の値をセットする.
1880        /// dst(I) = src1(I) op scalar .
1881        /// 比較結果が真(TRUE)であれば dst(I) には 0xff(要素すべてのビットが 1 )をセットし,それ以外の場合(FALSE)であれば 0 をセットする.
1882        /// すべての配列(出力配列を除く)は同じタイプで,配列のサイズ(またはROIのサイズ)も同じでなければならない.
1883        /// </summary>
1884        /// <param name="src">入力配列(シングルチャンネル)</param>
1885        /// <param name="value">それぞれの配列要素と比較されるスカラー</param>
1886        /// <param name="dst">出力配列(タイプは 8u か 8s でないといけない)</param>
1887        /// <param name="cmp_op">比較方法を示すフラグ</param>
1888        public static void CmpS(this CvArr src, double value, CvArr dst, ArrComparison cmp_op)
1889        {
1890            if (src == null)
1891                throw new ArgumentNullException("src");
1892            if (dst == null)
1893                throw new ArgumentNullException("dst");
1894            CvDll.cvCmpS(src.CvPtr, value, dst.CvPtr, cmp_op);
1895        }
1896        #endregion
1897        #region CompareHist
1898        /// <summary>
1899        /// 2つの密なヒストグラムを比較する.
1900        /// 疎なヒストグラム,あるいは重み付けされた点が集まったような,より一般的な構造を比較するためには,関数cvCalcEMD2 を用いる方が良い場合もある.
1901        /// </summary>
1902        /// <param name="hist1">1番目の密なヒストグラム</param>
1903        /// <param name="hist2">2番目の密なヒストグラム</param>
1904        /// <param name="method">比較手法</param>
1905        public static double CompareHist(CvHistogram hist1, CvHistogram hist2, HistogramComparison method)
1906        {
1907            if (hist1 == null)
1908                throw new ArgumentNullException("hist1");
1909            if (hist2 == null)
1910                throw new ArgumentNullException("hist2");
1911            return CvDll.cvCompareHist(hist1.CvPtr, hist2.CvPtr, method);
1912        }
1913        #endregion
1914        #region ComputeCorrespondEpilines
1915        /// <summary>
1916        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
1917        /// </summary>
1918        /// <param name="points">入力点で大きさは2xN, Nx2, 3xN,また はNx3の配列である (ここで N は 点の数). マルチチャンネルの 1xN,または Nx1 の配列も使用可能.</param>
1919        /// <param name="which_image">pointsを含む画像のインデックス(1 または 2).</param>
1920        /// <param name="fundamental_matrix">基礎行列</param>
1921        /// <param name="correspondent_lines">計算されたエピポーラ線.大きさは3xN また Nx3 の配列.</param>
1922        public static void ComputeCorrespondEpilines(this CvMat points, int which_image, CvMat fundamental_matrix, out CvMat correspondent_lines)
1923        {
1924            if (points == null)
1925                throw new ArgumentNullException("points");
1926            if (fundamental_matrix == null)
1927                throw new ArgumentNullException("fundamental_matrix");
1928            int size = Math.Max(points.Rows, points.Cols);
1929            correspondent_lines = new CvMat(1, size, MatrixType.F32C1);
1930            CvDll.cvComputeCorrespondEpilines(points.CvPtr, which_image, fundamental_matrix.CvPtr, correspondent_lines.CvPtr);
1931        }
1932        #endregion
1933        #region ContourArea
1934        /// <summary>
1935        /// 輪郭全体の領域,または輪郭の一部を計算する.
1936        /// 後者の場合,輪郭の弧と選択された2点を繋ぐ弦で区切られたエリア全体が計算される.
1937        /// </summary>
1938        /// <param name="contour">輪郭(頂点のシーケンスまたは配列)</param>
1939        /// <returns></returns>
1940        public static double ContourArea(this CvArr contour)
1941        {
1942            return ContourArea(contour, CvSlice.WholeSeq);
1943        }
1944        /// <summary>
1945        /// 輪郭全体の領域,または輪郭の一部を計算する.
1946        /// 後者の場合,輪郭の弧と選択された2点を繋ぐ弦で区切られたエリア全体が計算される.
1947        /// </summary>
1948        /// <param name="contour">輪郭(頂点のシーケンスまたは配列)</param>
1949        /// <param name="slice">注目領域の輪郭の始点と終点.デフォルトでは全領域が計算される.</param>
1950        /// <returns></returns>
1951        public static double ContourArea(this CvArr contour, CvSlice slice)
1952        {
1953            if (contour == null)
1954            {
1955                throw new ArgumentNullException("contour");
1956            }
1957            return CvDll.cvContourArea(contour.CvPtr, slice);
1958        }
1959        #endregion
1960        #region ContoursMoments
1961#if LANG_JA
1962        /// <summary>
1963        /// Alias for Moments with CvSeq contours
1964        /// </summary>
1965        /// <param name="contour"></param>
1966        /// <param name="moments"></param>
1967        /// <returns></returns>
1968#else
1969        /// <summary>
1970        /// Alias for Moments with CvSeq contours
1971        /// </summary>
1972        /// <param name="contour">Contours</param>
1973        /// <param name="moments">Moments</param>
1974        /// <returns></returns>
1975#endif
1976        public static double ContoursMoments(this CvSeq contour, CvMoments moments)
1977        {
1978            if (contour == null)
1979            {
1980                throw new ArgumentNullException("contour");
1981            }
1982            //return CvDll.cvMoments(contour.CvPtr, moments.CvPtr, false);
1983            return CvDll.cvMoments(contour.CvPtr, moments, false);
1984        }
1985        #endregion
1986        #region ContourPerimeter
1987#if LANG_JA
1988        /// <summary>
1989        /// cvArcLength(curve,Whole_Seq,1) のエイリアス
1990        /// </summary>
1991        /// <param name="contour"></param>
1992        /// <param name="moments"></param>
1993        /// <returns></returns>
1994#else
1995        /// <summary>
1996        /// Alias for cvArcLength(curve,Whole_Seq,1)
1997        /// </summary>
1998        /// <param name="contour">Contours</param>
1999        /// <returns></returns>
2000#endif
2001        public static double ContourPerimeter(this CvArr contour)
2002        {
2003            if (contour == null)
2004            {
2005                throw new ArgumentNullException("contour");
2006            }
2007            return ArcLength(contour, CvSlice.WholeSeq, 1);
2008        }
2009        #endregion
2010        #region Convert
2011        /// <summary>
2012        /// scale=1, shift=0 でのcvConvertScale呼び出し. 任意の線形変換によって配列の値を変換する.
2013        /// </summary>
2014        /// <param name="src">入力配列</param>
2015        /// <param name="dst">出力配列(デプスは 8u)</param>
2016        public static void Convert(this CvArr src, CvArr dst)
2017        {
2018            ConvertScale(src, dst);
2019        }
2020        #endregion
2021        #region ConvertPointsHomogeneous
2022        /// <summary>
2023        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
2024        /// </summary>
2025        /// <param name="src">入力点の配列.大きさは2xN, Nx2, 3xN, Nx3, 4xN,またはNx4(ここでNは点の数).マルチチャンネルの1xNまたはNx1の配列も使用可能.</param>
2026        /// <param name="dst">出力点の配列.入力配列と同じ数の点が含まれる次元数は,同じ, あるいは入力より1少ないか1大きい.そして2..4の範囲内でなければならない. </param>
2027        public static void ConvertPointsHomogenious(this CvMat src, CvMat dst)
2028        {
2029            ConvertPointsHomogenious(src, dst);
2030        }
2031        /// <summary>
2032        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
2033        /// </summary>
2034        /// <param name="src">入力点の配列.大きさは2xN, Nx2, 3xN, Nx3, 4xN,またはNx4(ここでNは点の数).マルチチャンネルの1xNまたはNx1の配列も使用可能.</param>
2035        /// <param name="dst">出力点の配列.入力配列と同じ数の点が含まれる次元数は,同じ, あるいは入力より1少ないか1大きい.そして2..4の範囲内でなければならない. </param>
2036        public static void ConvertPointsHomogeneous(this CvMat src, CvMat dst)
2037        {
2038            if (src == null)
2039                throw new ArgumentNullException("src");
2040            if (dst == null)
2041                throw new ArgumentNullException("dst");
2042            CvDll.cvConvertPointsHomogeneous(src.CvPtr, dst.CvPtr);
2043        }
2044        #endregion
2045        #region ConvertScale
2046        /// <summary>
2047        /// 任意の線形変換によって配列の値を変換する.[scale=1, shift=0]
2048        /// </summary>
2049        /// <param name="src">入力配列</param>
2050        /// <param name="dst">出力配列(デプスは 8u)</param>
2051        public static void ConvertScale(this CvArr src, CvArr dst)
2052        {
2053            ConvertScale(src, dst, 1, 0);
2054        }
2055        /// <summary>
2056        /// 任意の線形変換によって配列の値を変換する.[shift=0]
2057        /// </summary>
2058        /// <param name="src">入力配列</param>
2059        /// <param name="dst">出力配列(デプスは 8u)</param>
2060        /// <param name="scale">ScaleAbs 係数</param>
2061        public static void ConvertScale(this CvArr src, CvArr dst, double scale)
2062        {
2063            ConvertScale(src, dst, scale, 0);
2064        }
2065        /// <summary>
2066        /// 任意の線形変換によって配列の値を変換する.
2067        /// </summary>
2068        /// <param name="src">入力配列</param>
2069        /// <param name="dst">出力配列(デプスは 8u)</param>
2070        /// <param name="scale">ScaleAbs 係数</param>
2071        /// <param name="shift">スケーリングした入力配列の要素に加える値</param>
2072        public static void ConvertScale(this CvArr src, CvArr dst, double scale, double shift)
2073        {
2074            if (src == null)
2075                throw new ArgumentNullException("src");
2076            if (dst == null)
2077                throw new ArgumentNullException("dst");
2078            CvDll.cvConvertScale(src.CvPtr, dst.CvPtr, scale, shift);
2079        }
2080        /// <summary>
2081        /// 任意の線形変換によって配列の値を変換する.[scale=1, shift=0]
2082        /// </summary>
2083        /// <param name="src">入力配列</param>
2084        /// <param name="dst">出力配列(デプスは 8u)</param>
2085        public static void CvtScale(this CvArr src, CvArr dst)
2086        {
2087            ConvertScale(src, dst, 1, 0);
2088        }
2089        /// <summary>
2090        /// 任意の線形変換によって配列の値を変換する.[shift=0]
2091        /// </summary>
2092        /// <param name="src">入力配列</param>
2093        /// <param name="dst">出力配列(デプスは 8u)</param>
2094        /// <param name="scale">ScaleAbs 係数</param>
2095        public static void CvtScale(this CvArr src, CvArr dst, double scale)
2096        {
2097            ConvertScale(src, dst, scale, 0);
2098        }
2099        /// <summary>
2100        /// 任意の線形変換によって配列の値を変換する.
2101        /// </summary>
2102        /// <param name="src">入力配列</param>
2103        /// <param name="dst">出力配列(デプスは 8u)</param>
2104        /// <param name="scale">ScaleAbs 係数</param>
2105        /// <param name="shift">スケーリングした入力配列の要素に加える値</param>
2106        public static void CvtScale(this CvArr src, CvArr dst, double scale, double shift)
2107        {
2108            ConvertScale(src, dst, scale, shift);
2109        }
2110        /// <summary>
2111        /// 任意の線形変換によって配列の値を変換する.[scale=1, shift=0]
2112        /// </summary>
2113        /// <param name="src">入力配列</param>
2114        /// <param name="dst">出力配列(デプスは 8u)</param>
2115        public static void Scale(this CvArr src, CvArr dst)
2116        {
2117            ConvertScale(src, dst, 1, 0);
2118        }
2119        /// <summary>
2120        /// 任意の線形変換によって配列の値を変換する.[shift=0]
2121        /// </summary>
2122        /// <param name="src">入力配列</param>
2123        /// <param name="dst">出力配列(デプスは 8u)</param>
2124        /// <param name="scale">ScaleAbs 係数</param>
2125        public static void Scale(this CvArr src, CvArr dst, double scale)
2126        {
2127            ConvertScale(src, dst, scale, 0);
2128        }
2129        /// <summary>
2130        /// 任意の線形変換によって配列の値を変換する.
2131        /// </summary>
2132        /// <param name="src">入力配列</param>
2133        /// <param name="dst">出力配列(デプスは 8u)</param>
2134        /// <param name="scale">ScaleAbs 係数</param>
2135        /// <param name="shift">スケーリングした入力配列の要素に加える値</param>
2136        public static void Scale(this CvArr src, CvArr dst, double scale, double shift)
2137        {
2138            ConvertScale(src, dst, scale, shift);
2139        }
2140        #endregion
2141        #region ConvertScaleAbs
2142        /// <summary>
2143        /// 任意の線形変換によって,入力配列の要素を8ビット符号無し整数型の配列に変換する.[scale=1, shift=0]
2144        /// </summary>
2145        /// <param name="src">入力配列</param>
2146        /// <param name="dst">出力配列(デプスは 8u)</param>
2147        public static void ConvertScaleAbs(this CvArr src, CvArr dst)
2148        {
2149            ConvertScaleAbs(src, dst, 1, 0);
2150        }
2151        /// <summary>
2152        /// 任意の線形変換によって,入力配列の要素を8ビット符号無し整数型の配列に変換する.[shift=0]
2153        /// </summary>
2154        /// <param name="src">入力配列</param>
2155        /// <param name="dst">出力配列(デプスは 8u)</param>
2156        /// <param name="scale">ScaleAbs 係数</param>
2157        public static void ConvertScaleAbs(this CvArr src, CvArr dst, double scale)
2158        {
2159            ConvertScaleAbs(src, dst, scale, 0);
2160        }
2161        /// <summary>
2162        /// 任意の線形変換によって,入力配列の要素を8ビット符号無し整数型の配列に変換する.
2163        /// </summary>
2164        /// <param name="src">入力配列</param>
2165        /// <param name="dst">出力配列(デプスは 8u)</param>
2166        /// <param name="scale">ScaleAbs 係数</param>
2167        /// <param name="shift">スケーリングした入力配列の要素に加える値</param>
2168        public static void ConvertScaleAbs(this CvArr src, CvArr dst, double scale, double shift)
2169        {
2170            if (src == null)
2171                throw new ArgumentNullException("src");
2172            if (dst == null)
2173                throw new ArgumentNullException("dst");
2174            CvDll.cvConvertScaleAbs(src.CvPtr, dst.CvPtr, scale, shift);
2175        }
2176        #endregion
2177        #region Copy
2178        /// <summary>
2179        /// 一つの配列を別の配列にコピーする.
2180        /// コピーの際は、ROI と COI が利用される.コピー元配列とコピー先配列は,同じ型,同じ次元,同じサイズでなければならない.
2181        /// </summary>
2182        /// <param name="src">コピー元画像</param>
2183        /// <param name="dst">コピー先の画像</param>
2184        public static void Copy(this CvArr src, CvArr dst)
2185        {
2186            Copy(src, dst, null);
2187        }
2188        /// <summary>
2189        /// 一つの配列を別の配列にコピーする.
2190        /// コピーの際は、ROI と COI が利用される.コピー元配列とコピー先配列は,同じ型,同じ次元,同じサイズでなければならない.
2191        /// </summary>
2192        /// <param name="src">コピー元画像</param>
2193        /// <param name="dst">コピー先の画像</param>
2194        /// <param name="mask">8 ビットシングルチャンネル配列の処理マスク.コピー先の配列の変更する要素を指定する.</param>
2195        public static void Copy(this CvArr src, CvArr dst, CvArr mask)
2196        {
2197            if (src == null)
2198                throw new ArgumentNullException("src");
2199            if (dst == null)
2200                throw new ArgumentNullException("dst");
2201            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
2202            CvDll.cvCopy(src.CvPtr, dst.CvPtr, maskPtr);
2203        }
2204        #endregion
2205        #region CopyMakeBorder
2206        /// <summary>
2207        /// 画像をコピーし,その周りに境界線をつける
2208        /// </summary>
2209        /// <param name="src">入力画像</param>
2210        /// <param name="dst">出力画像</param>
2211        /// <param name="offset">入力画像(あるいはROI)がコピーされる出力画像内矩形領域の左上角座標 (左下に原点を持つ画像の場合は,左下角座標).</param>
2212        /// <param name="bordertype">コピーされた矩形領域の周りに生成する境界線のタイプ</param>
2213        public static void CopyMakeBorder(this CvArr src, CvArr dst, CvPoint offset, BorderType bordertype)
2214        {
2215            CopyMakeBorder(src, dst, offset, bordertype, CvScalar.ScalarAll(0));
2216        }
2217        /// <summary>
2218        /// 画像をコピーし,その周りに境界線をつける
2219        /// </summary>
2220        /// <param name="src">入力画像</param>
2221        /// <param name="dst">出力画像</param>
2222        /// <param name="offset">入力画像(あるいはROI)がコピーされる出力画像内矩形領域の左上角座標 (左下に原点を持つ画像の場合は,左下角座標).</param>
2223        /// <param name="bordertype">コピーされた矩形領域の周りに生成する境界線のタイプ</param>
2224        /// <param name="value">bordertype=Constant の場合は境界を埋める値</param>
2225        public static void CopyMakeBorder(this CvArr src, CvArr dst, CvPoint offset, BorderType bordertype, CvScalar value)
2226        {
2227            if (src == null)
2228                throw new ArgumentNullException("src");
2229            if (dst == null)
2230                throw new ArgumentNullException("dst");
2231            CvDll.cvCopyMakeBorder(src.CvPtr, dst.CvPtr, offset, bordertype, value);
2232        }
2233        #endregion
2234        #region CornerEigenValsAndVecs
2235        /// <summary>
2236        /// コーナー検出のために画像ブロックの固有値と固有ベクトルを計算する.
2237        /// </summary>
2238        /// <param name="image">入力画像</param>
2239        /// <param name="eigenvv">結果保存用の画像.入力画像の6倍のサイズが必要.</param>
2240        /// <param name="block_size">隣接ブロックのサイズ</param>
2241        public static void CornerEigenValsAndVecs(this CvArr image, CvArr eigenvv, int block_size)
2242        {
2243            CornerEigenValsAndVecs(image, eigenvv, block_size, 3);
2244        }
2245        /// <summary>
2246        /// コーナー検出のために画像ブロックの固有値と固有ベクトルを計算する.
2247        /// </summary>
2248        /// <param name="image">入力画像</param>
2249        /// <param name="eigenvv">結果保存用の画像.入力画像の6倍のサイズが必要.</param>
2250        /// <param name="block_size">隣接ブロックのサイズ</param>
2251        /// <param name="aperture_size">Sobel演算子のアパーチャサイズ(cvSobel参照).</param>
2252        public static void CornerEigenValsAndVecs(this CvArr image, CvArr eigenvv, int block_size, int aperture_size)
2253        {
2254            if (image == null)
2255                throw new ArgumentNullException("image");
2256            if (eigenvv == null)
2257                throw new ArgumentNullException("eigenvv");
2258            CvDll.cvCornerEigenValsAndVecs(image.CvPtr, eigenvv.CvPtr, block_size, aperture_size);
2259        }
2260        #endregion
2261        #region CornerHarris
2262        /// <summary>
2263        /// 入力画像について Harris エッジ検出を行う.
2264        /// cvCornerMinEigenVal や cvCornerEigenValsAndVecsと同様の機能を持ち,それぞれのピクセルにおいて,
2265        /// block_size×block_size 隣接における 2×2 サイズの勾配から共変動行列M を計算する.その後,
2266        /// det(M) - k * trace(M)^2
2267        /// を計算し,検出結果として出力画像に保存する.結果画像の極大値を求めることで,画像のコーナーを検出することができる.
2268        /// </summary>
2269        /// <param name="image">入力画像</param>
2270        /// <param name="harris_responce">検出結果を保存する画像.入力画像 image と同じサイズでなくてはならない.</param>
2271        /// <param name="block_size">隣接ブロックのサイズ</param>
2272        public static void CornerHarris(this CvArr image, CvArr harris_responce, int block_size)
2273        {
2274            CornerHarris(image, harris_responce, block_size, 3, 0.04);
2275        }
2276        /// <summary>
2277        /// 入力画像について Harris エッジ検出を行う.
2278        /// cvCornerMinEigenVal や cvCornerEigenValsAndVecsと同様の機能を持ち,それぞれのピクセルにおいて,
2279        /// block_size×block_size 隣接における 2×2 サイズの勾配から共変動行列M を計算する.その後,
2280        /// det(M) - k * trace(M)^2
2281        /// を計算し,検出結果として出力画像に保存する.結果画像の極大値を求めることで,画像のコーナーを検出することができる.
2282        /// </summary>
2283        /// <param name="image">入力画像</param>
2284        /// <param name="harris_responce">検出結果を保存する画像.入力画像 image と同じサイズでなくてはならない.</param>
2285        /// <param name="block_size">隣接ブロックのサイズ</param>
2286        /// <param name="aperture_size">Sobel演算子のアパーチャサイズ(cvSobel参照).入力画像が浮動小数点型である場合,このパラメータは差分を計算するために用いられる固定小数点型フィルタの数を表す</param>
2287        public static void CornerHarris(this CvArr image, CvArr harris_responce, int block_size, int aperture_size)
2288        {
2289            CornerHarris(image, harris_responce, block_size, aperture_size, 0.04);
2290        }
2291        /// <summary>
2292        /// 入力画像について Harris エッジ検出を行う.
2293        /// cvCornerMinEigenVal や cvCornerEigenValsAndVecsと同様の機能を持ち,それぞれのピクセルにおいて,
2294        /// block_size×block_size 隣接における 2×2 サイズの勾配から共変動行列M を計算する.その後,
2295        /// det(M) - k * trace(M)^2
2296        /// を計算し,検出結果として出力画像に保存する.結果画像の極大値を求めることで,画像のコーナーを検出することができる.
2297        /// </summary>
2298        /// <param name="image">入力画像</param>
2299        /// <param name="harris_responce">検出結果を保存する画像.入力画像 image と同じサイズでなくてはならない.</param>
2300        /// <param name="block_size">隣接ブロックのサイズ</param>
2301        /// <param name="aperture_size">Sobel演算子のアパーチャサイズ(cvSobel参照).入力画像が浮動小数点型である場合,このパラメータは差分を計算するために用いられる固定小数点型フィルタの数を表す</param>
2302        /// <param name="k">Harris検出器のパラメータ</param>
2303        public static void CornerHarris(this CvArr image, CvArr harris_responce, int block_size, int aperture_size, double k)
2304        {
2305            if (image == null)
2306                throw new ArgumentNullException("image");
2307            if (harris_responce == null)
2308                throw new ArgumentNullException("harris_responce");
2309            CvDll.cvCornerHarris(image.CvPtr, harris_responce.CvPtr, block_size, aperture_size, k);
2310        }
2311        #endregion
2312        #region CornerMinEigenVal
2313        /// <summary>
2314        /// コーナー検出のために,画像ブロックの最小固有値を計算する.
2315        /// すべてのピクセルについて,隣接ブロックにおける導関数の共変動行列の最小固有値だけを求める関数である.
2316        /// </summary>
2317        /// <param name="image">入力画像</param>
2318        /// <param name="eigenval">最小固有値を保存する画像.image と同じサイズでなくてはならない.</param>
2319        /// <param name="block_size">隣接ブロックのサイズ</param>
2320        public static void CornerMinEigenVal(this CvArr image, CvArr eigenval, int block_size)
2321        {
2322            CornerMinEigenVal(image, eigenval, block_size, 3);
2323        }
2324        /// <summary>
2325        /// コーナー検出のために,画像ブロックの最小固有値を計算する.
2326        /// すべてのピクセルについて,隣接ブロックにおける導関数の共変動行列の最小固有値だけを求める関数である.
2327        /// </summary>
2328        /// <param name="image">入力画像</param>
2329        /// <param name="eigenval">最小固有値を保存する画像.image と同じサイズでなくてはならない.</param>
2330        /// <param name="block_size">隣接ブロックのサイズ</param>
2331        /// <param name="aperture_size">Sobel演算子のアパーチャサイズ(cvSobel参照).入力画像が浮動小数点型である場合,このパラメータは差分を計算するために用いられる固定小数点型フィルタの数を表す</param>
2332        public static void CornerMinEigenVal(this CvArr image, CvArr eigenval, int block_size, int aperture_size)
2333        {
2334            if (image == null)
2335                throw new ArgumentNullException("image");
2336            if (eigenval == null)
2337                throw new ArgumentNullException("eigenval");
2338            CvDll.cvCornerMinEigenVal(image.CvPtr, eigenval.CvPtr, block_size, aperture_size);
2339        }
2340        #endregion
2341        #region CountNonZero
2342        /// <summary>
2343        /// 配列要素において 0 ではない要素をカウントする.
2344        /// 配列が IplImage の場合, ROI,COI の両方に対応している.
2345        /// </summary>
2346        /// <param name="arr">配列(シングルチャンネルまたはCOIがセットされたマルチチャンネルの画像).</param>
2347        /// <returns>0 ではない要素数</returns>
2348        public static int CountNonZero(this CvArr arr)
2349        {
2350            if (arr == null)
2351            {
2352                throw new ArgumentNullException("arr");
2353            }
2354            return CvDll.cvCountNonZero(arr.CvPtr);
2355        }
2356        #endregion
2357        #region CreateCameraCapture
2358        /// <summary>
2359        /// カメラからのビデオキャプチャを初期化する.
2360        /// Windows では,次の二つのカメラインタフェースが利用できる:Video for Windows(VFW),Matrox Imaging Library(MIL).
2361        /// Linux では,次の二つカメラインタフェースが利用できる:Video for Linux(V4L),FireWire(IEEE1394).
2362        /// </summary>
2363        /// <param name="index">使われるカメラのインデックス.使用するカメラが1台のとき,あるいは,何台のカメラを使うかが重要でないときは,-1 でも問題ない場合もある.</param>
2364        /// <returns></returns>
2365        public static CvCapture CreateCameraCapture(int index)
2366        {
2367            return new CvCapture(index);
2368        }
2369        /// <summary>
2370        /// カメラからのビデオキャプチャを初期化する.
2371        /// Windows では,次の二つのカメラインタフェースが利用できる:Video for Windows(VFW),Matrox Imaging Library(MIL).
2372        /// Linux では,次の二つカメラインタフェースが利用できる:Video for Linux(V4L),FireWire(IEEE1394).
2373        /// </summary>
2374        /// <param name="device">使われるカメラの種類</param>
2375        /// <returns></returns>
2376        public static CvCapture CreateCameraCapture(CaptureDevice device)
2377        {
2378            return new CvCapture(device);
2379        }
2380        #endregion
2381        #region CreateChildMemStorage
2382        /// <summary>
2383        /// メモリ確保/解放機構の違いを除いて,単純なメモリストレージに似た子メモリストレージを生成する.
2384        /// </summary>
2385        /// <param name="parent">親メモリストレージ</param>
2386        /// <returns></returns>
2387        public static CvMemStorage CreateChildMemStorage(CvMemStorage parent)
2388        {
2389            if (parent == null)
2390            {
2391                throw new ArgumentNullException("parent");
2392            }
2393            IntPtr ptr = CvDll.cvCreateChildMemStorage(parent.CvPtr);
2394            if (ptr == IntPtr.Zero)
2395                return null;
2396            else
2397                return new CvMemStorage(ptr);
2398        }
2399        #endregion
2400        #region CreateData
2401        /// <summary>
2402        /// 画像,行列あるいは多次元配列のデータを確保する.
2403        /// </summary>
2404        /// <param name="arr">配列ヘッダ</param>
2405        public static void CreateData(this CvArr arr)
2406        {
2407            if (arr == null)
2408            {
2409                throw new ArgumentNullException("arr");
2410            }
2411            CvDll.cvCreateData(arr.CvPtr);
2412        }
2413        #endregion
2414        #region CreateHist
2415        /// <summary>
2416        /// 指定サイズのヒストグラムを生成し,そのヒストグラムの参照を返す.
2417        /// 配列 ranges が null の場合は,ヒストグラムのビンは,後から関数 cvSetHistBinRanges を用いて決定される.
2418        /// しかし,cvCalcHist と cvCalcBackProject においてはビンのレンジを設定せずに,8ビット画像を,0..255 の等間隔ビンであると仮定して処理する.
2419        /// </summary>
2420        /// <param name="dims">ヒストグラム各次元のサイズを示す配列</param>
2421        /// <param name="type">ヒストグラム表現フォーマット</param>
2422        public static CvHistogram CreateHist(int[] dims, HistogramFormat type)
2423        {
2424            if (dims == null)
2425            {
2426                throw new ArgumentNullException("dims");
2427            }
2428            return new CvHistogram(dims, type);
2429        }
2430        /// <summary>
2431        /// 指定サイズのヒストグラムを生成し,そのヒストグラムの参照を返す.
2432        /// 配列 ranges が null の場合は,ヒストグラムのビンは,後から関数 cvSetHistBinRanges を用いて決定される.
2433        /// しかし,cvCalcHist と cvCalcBackProject においてはビンのレンジを設定せずに,8ビット画像を,0..255 の等間隔ビンであると仮定して処理する.
2434        /// </summary>
2435        /// <param name="dims">ヒストグラム各次元のサイズを示す配列</param>
2436        /// <param name="type">ヒストグラム表現フォーマット</param>
2437        /// <param name="ranges">ヒストグラムのビン(bin)(値域)を示す配列.このパラメータの意味はパラメータuniformに依存している.
2438        /// このレンジは,ヒストグラムを計算したり,またどのヒストグラムのビンが入力画像のどの値やどのデータ要素に対応するかを決めるためのバックプロジェクションで用いられる.
2439        /// null の場合は,後から関数 cvSetHistBinRanges を用いて決定される</param>
2440        public static CvHistogram CreateHist(int[] dims, HistogramFormat type, float[][] ranges)
2441        {
2442            if (dims == null)
2443            {
2444                throw new ArgumentNullException("dims");
2445            }
2446            return new CvHistogram(dims, type, ranges);
2447        }
2448        /// <summary>
2449        /// 指定サイズのヒストグラムを生成し,そのヒストグラムの参照を返す.
2450        /// 配列 ranges が null の場合は,ヒストグラムのビンは,後から関数 cvSetHistBinRanges を用いて決定される.
2451        /// しかし,cvCalcHist と cvCalcBackProject においてはビンのレンジを設定せずに,8ビット画像を,0..255 の等間隔ビンであると仮定して処理する.
2452        /// </summary>
2453        /// <param name="dims">ヒストグラム各次元のサイズを示す配列</param>
2454        /// <param name="type">ヒストグラム表現フォーマット</param>
2455        /// <param name="ranges">ヒストグラムのビン(bin)(値域)を示す配列.このパラメータの意味はパラメータuniformに依存している.
2456        /// このレンジは,ヒストグラムを計算したり,またどのヒストグラムのビンが入力画像のどの値やどのデータ要素に対応するかを決めるためのバックプロジェクションで用いられる.
2457        /// null の場合は,後から関数 cvSetHistBinRanges を用いて決定される</param>
2458        /// <param name="uniform">一様性に関するフラグ</param>
2459        /// <returns>多次元ヒストグラムクラス</returns>
2460        public static CvHistogram CreateHist(int[] dims, HistogramFormat type, float[][] ranges, bool uniform)
2461        {
2462            if (dims == null)
2463            {
2464                throw new ArgumentNullException("dims");
2465            }
2466            return new CvHistogram(dims, type, ranges, uniform);
2467        }
2468        #endregion
2469        #region CreateImage
2470        /// <summary>
2471        /// 画像のヘッダを作成し,データ領域を確保する
2472        /// </summary>
2473        /// <param name="size">画像の幅と高さ</param>
2474        /// <param name="depth">画像要素のビットデプス</param>
2475        /// <param name="channels">要素(ピクセル)毎のチャンネル数.1,2,3,4 のいずれか.</param>
2476        /// <returns>画像ポインタ</returns>
2477        public static IplImage CreateImage(CvSize size, BitDepth depth, int channels)
2478        {
2479            IntPtr ptr = CvDll.cvCreateImage(size, depth, channels);
2480            if (ptr == IntPtr.Zero)
2481                return null;
2482            else
2483                return new IplImage(ptr);
2484        }
2485        #endregion
2486        #region CreateImageHeader
2487        /// <summary>
2488        /// メモリ確保と初期化を行う
2489        /// </summary>
2490        /// <param name="size">画像の幅と高さ</param>
2491        /// <param name="depth">画像要素のビットデプス</param>
2492        /// <param name="channels">要素(ピクセル)毎のチャンネル数.1,2,3,4 のいずれか.このチャンネルはインタリーブされる.例えば,通常のカラー画像のデータレイアウトは,b0 g0 r0 b1 g1 r1 ...となっている.</param>
2493        /// <returns>画像ポインタ</returns>
2494        public static IplImage CreateImageHeader(CvSize size, BitDepth depth, int channels)
2495        {
2496            IntPtr ptr = CvDll.cvCreateImageHeader(size, depth, channels);
2497            if (ptr == IntPtr.Zero)
2498                return null;
2499            else
2500                return new IplImage(ptr);
2501        }
2502        #endregion
2503        #region CreateKalman
2504        /// <summary>
2505        /// カルマンフィルタ構造体の領域確保を行う.
2506        /// </summary>
2507        /// <param name="dynam_params">状態ベクトルの次元数</param>
2508        /// <param name="measure_params">観測ベクトルの次元</param>
2509        /// <returns></returns>
2510        public static CvKalman CreateKalman(int dynam_params, int measure_params)
2511        {
2512            return new CvKalman(dynam_params, measure_params);
2513        }
2514        /// <summary>
2515        /// カルマンフィルタ構造体の領域確保を行う.
2516        /// </summary>
2517        /// <param name="dynam_params">状態ベクトルの次元数</param>
2518        /// <param name="measure_params">観測ベクトルの次元</param>
2519        /// <param name="control_params">コントロールベクトルの次元</param>
2520        /// <returns></returns>
2521        public static CvKalman CreateKalman(int dynam_params, int measure_params, int control_params)
2522        {
2523            return new CvKalman(dynam_params, measure_params, control_params);
2524        }
2525        #endregion
2526        #region CreateMat
2527        /// <summary>
2528        /// 新たな行列とその内部データのためのヘッダを確保し,作成された行列への参照を返す.
2529        /// </summary>
2530        /// <param name="rows">行列の行数</param>
2531        /// <param name="cols">行列の列数</param>
2532        /// <param name="type">行列要素の種類</param>
2533        /// <returns>行列</returns>
2534        public static CvMat CreateMat(int rows, int cols, MatrixType type)
2535        {
2536            IntPtr ptr = CvDll.cvCreateMat(rows, cols, type);
2537            if (ptr == IntPtr.Zero)
2538                return null;
2539            else
2540                return new CvMat(ptr);
2541        }
2542        #endregion
2543        #region CreateMatHeader
2544        /// <summary>
2545        /// 新たな行列のヘッダを作成し,その参照を返す.
2546        /// さらに,cvCreateData を用いるか,cvSetData により,ユーザが確保したデータ領域を明示的にセットすることで,行列データが確保される.
2547        /// </summary>
2548        /// <param name="rows">行列の行数</param>
2549        /// <param name="cols">行列の列数</param>
2550        /// <param name="type">行列要素の種類</param>
2551        public static CvMat CreateMatHeader(int rows, int cols, MatrixType type)
2552        {
2553            IntPtr ptr = CvDll.cvCreateMatHeader(rows, cols, type);
2554            return new CvMat(ptr);
2555        }
2556        #endregion
2557        #region CreateMemStorage
2558        /// <summary>
2559        /// メモリストレージを生成し,その参照を返す.初期状態ではストレージは空である.
2560        /// block_sizeを除くヘッダのフィールドは全て0に設定されている.
2561        /// </summary>
2562        public static CvMemStorage CreateMemStorage()
2563        {
2564            return CreateMemStorage(0);
2565        }
2566        /// <summary>
2567        /// メモリストレージを生成し,その参照を返す.初期状態ではストレージは空である.
2568        /// block_sizeを除くヘッダのフィールドは全て0に設定されている.
2569        /// </summary>
2570        /// <param name="block_size">ストレージブロックのバイト単位のサイズ.0の場合,デフォルト値(現在は≈64K)が使われる.</param>
2571        public static CvMemStorage CreateMemStorage(int block_size)
2572        {
2573            IntPtr ptr = CvDll.cvCreateMemStorage(block_size);
2574            if (ptr == IntPtr.Zero)
2575                return null;
2576            else
2577                return new CvMemStorage(ptr);
2578        }
2579        #endregion
2580        #region CreateSeq
2581        /// <summary>
2582        /// シーケンスを作成し,そのポインタを返す.
2583        /// </summary>
2584        /// <param name="seq_flags">生成されたシーケンスのフラグ.生成されたシーケンスが,特定のシーケンスタイプを引数にとるような関数に一切渡されない場合は,この値に0を指定してもかまわない.そうでない場合は,定義済みのシーケンスタイプのリストから適切なタイプが選択されなければならない.</param>
2585        /// <param name="header_size">シーケンスのヘッダサイズ.sizeof(CvSeq)以上でなければならない. また,特別なタイプかその拡張が指示されている場合,そのタイプは基本タイプのヘッダと合致していなければならない.</param>
2586        /// <param name="elem_size">シーケンスの要素サイズ(バイト単位).サイズはシーケンスタイプと合致しなければならない.例えば,点群のシーケンスを作成する場合,要素タイプにCV_SEQ_ELTYPE_POINTを指定し,パラメータ elem_size は sizeof(CvPoint) と等しくなければならない.</param>
2587        /// <param name="storage">シーケンスが保存される場所</param>
2588        /// <returns></returns>
2589        public static CvSeq<T> CreateSeq<T>(SeqType seq_flags, int header_size, int elem_size, CvMemStorage storage) where T : struct
2590        {
2591            if (storage == null)
2592            {
2593                throw new ArgumentNullException("storage");
2594            }
2595            IntPtr ptr = CvDll.cvCreateSeq(seq_flags, header_size, elem_size, storage.CvPtr);
2596            if (ptr == IntPtr.Zero)
2597                return null;
2598            else
2599                return new CvSeq<T>(ptr);
2600        }
2601        #endregion
2602        #region CreateStereoBMState
2603        /// <summary>
2604        /// ステレオブロックマッチング構造体を作成する
2605        /// </summary>
2606        /// <returns>ステレオブロックマッチング構造体</returns>
2607        public static CvStereoBMState CreateStereoBMState()
2608        {
2609            return new CvStereoBMState();
2610        }
2611        /// <summary>
2612        /// ステレオブロックマッチング構造体を作成する
2613        /// </summary>
2614        /// <param name="preset">あらかじめ定義されたパラメータのID.構造体を作成した後で,任意のパラメータをオーバーライドできる. </param>
2615        /// <returns>ステレオブロックマッチング構造体</returns>
2616        public static CvStereoBMState CreateStereoBMState(StereoBMPreset preset)
2617        {
2618            return new CvStereoBMState(preset);
2619        }
2620        /// <summary>
2621        /// ステレオブロックマッチング構造体を作成する
2622        /// </summary>
2623        /// <param name="preset">あらかじめ定義されたパラメータのID.構造体を作成した後で,任意のパラメータをオーバーライドできる. </param>
2624        /// <param name="numberOfDisparities">視差数(最大視差-最小視差). このパラメータが 0 の場合,preset から選択される. そうでない場合は,与えられた値が preset の値をオーバーライドする.</param>
2625        /// <returns>ステレオブロックマッチング構造体</returns>
2626        public static CvStereoBMState CreateStereoBMState(StereoBMPreset preset, int numberOfDisparities)
2627        {
2628            return new CvStereoBMState(preset, numberOfDisparities);
2629        }
2630        #endregion
2631        #region CreateStereoGCState
2632        /// <summary>
2633        /// グラフカットステレオマッチングアルゴリズムの構造体を作成する
2634        /// </summary>
2635        /// <param name="numberOfDisparities">視差数.視差の探索範囲は, state-&gt;minDisparity &lt;= disparity &lt; state-&gt;minDisparity + state-&gt;numberOfDisparities となる.</param>
2636        /// <param name="maxIters">繰り返し計算の最大数. 各繰り返しにおいて,すべての(あるいは,適度な数の)α拡張を行う. このアルゴリズムは,コスト関数全体を減少させるα拡張が見つからなかった場合は,そこで終了する.</param>
2637        /// <returns>グラフカットステレオマッチングアルゴリズムの構造体</returns>
2638        public static CvStereoGCState CreateStereoGCState(int numberOfDisparities, int maxIters)
2639        {
2640            return new CvStereoGCState(numberOfDisparities, maxIters);
2641        }
2642        #endregion
2643        #region CreateStructuringElementEx
2644        /// <summary>
2645        /// 膨張・収縮処理に用いる構造要素を生成する
2646        /// </summary>
2647        /// <param name="cols">構造要素の列数</param>
2648        /// <param name="rows">構造要素の行数</param>
2649        /// <param name="anchor_x">構造要素の原点のx座標</param>
2650        /// <param name="anchor_y">構造要素の原点のy座標</param>
2651        /// <param name="shape">構造要素の形状</param>
2652        /// <returns>構造要素</returns>
2653        public static IplConvKernel CreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, ElementShape shape)
2654        {
2655            return new IplConvKernel(cols, rows, anchor_x, anchor_y, shape);
2656        }
2657        /// <summary>
2658        /// 膨張・収縮処理に用いる構造要素を生成する
2659        /// </summary>
2660        /// <param name="cols">構造要素の列数</param>
2661        /// <param name="rows">構造要素の行数</param>
2662        /// <param name="anchor_x">構造要素の原点のx座標</param>
2663        /// <param name="anchor_y">構造要素の原点のy座標</param>
2664        /// <param name="shape">構造要素の形状</param>
2665        /// <param name="values">構造要素データへのポインタ。このパラメータは形状がCV_SHAPE_CUSTOMのときのみ有効</param>
2666        /// <returns>構造要素</returns>
2667        public static IplConvKernel CreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, ElementShape shape, int[,] values)
2668        {
2669            return new IplConvKernel(cols, rows, anchor_x, anchor_y, shape, values);
2670        }
2671        #endregion
2672        #region CreateSubdiv2D
2673        /// <summary>
2674        /// CvSubdiv2Dを生成する。
2675        /// このあと、cvInitSubdivDelaunay2Dで初期化するべし
2676        /// </summary>
2677        /// <param name="subdiv_type"></param>
2678        /// <param name="header_size"></param>
2679        /// <param name="vtx_size"></param>
2680        /// <param name="quadedge_size"></param>
2681        /// <param name="storage"></param>
2682        /// <returns></returns>
2683        public static CvSubdiv2D CreateSubdiv2D(SeqType subdiv_type, Int32 header_size, Int32 vtx_size, Int32 quadedge_size, CvMemStorage storage)
2684        {
2685            if (storage == null)
2686            {
2687                throw new ArgumentNullException("storage");
2688            }
2689            IntPtr ptr = CvDll.cvCreateSubdiv2D(subdiv_type, header_size, vtx_size, quadedge_size, storage.CvPtr);
2690            if (ptr == IntPtr.Zero)
2691                return null;
2692            else
2693                return new CvSubdiv2D(ptr);
2694        }
2695        #endregion
2696        #region CreateTrackbar
2697        /// <summary>
2698        /// 指定された名前と範囲のトラックバー(スライダ,レンジコントロールとも呼ばれる)を作成する.
2699        /// 作成されたトラックバーは,与えられたウィンドウの最上段に表示される.
2700        /// </summary>
2701        /// <param name="trackbar_name">トラックバーの名前</param>
2702        /// <param name="window_name">トラックバーの親ウィンドウの名前</param>
2703        /// <returns></returns>
2704        public static Int32 CreateTrackbar(string trackbar_name, string window_name)
2705        {
2706            trackbarValue = 0;
2707            return CvDll.cvCreateTrackbar(trackbar_name, window_name, ref trackbarValue, 10, null);
2708        }
2709        /// <summary>
2710        /// 指定された名前と範囲のトラックバー(スライダ,レンジコントロールとも呼ばれる)を作成する.
2711        /// 作成されたトラックバーは,与えられたウィンドウの最上段に表示される.
2712        /// </summary>
2713        /// <param name="trackbar_name">トラックバーの名前</param>
2714        /// <param name="window_name">トラックバーの親ウィンドウの名前</param>
2715        /// <param name="value">スライダの初期位置</param>
2716        /// <param name="count">スライダの最大値.最小値は常に 0.</param>
2717        /// <returns></returns>
2718        public static Int32 CreateTrackbar(string trackbar_name, string window_name, ref Int32 value, Int32 count)
2719        {
2720            return CvDll.cvCreateTrackbar(trackbar_name, window_name, ref value, count, null);
2721        }
2722        /// <summary>
2723        /// 指定された名前と範囲のトラックバー(スライダ,レンジコントロールとも呼ばれる)を作成する.
2724        /// 作成されたトラックバーは,与えられたウィンドウの最上段に表示される.
2725        /// </summary>
2726        /// <param name="trackbar_name">トラックバーの名前</param>
2727        /// <param name="window_name">トラックバーの親ウィンドウの名前</param>
2728        /// <param name="value">スライダの初期位置</param>
2729        /// <param name="count">スライダの最大値.最小値は常に 0.</param>
2730        /// <param name="on_change">スライダの位置が変更されるたびに呼び出されるデリゲート</param>
2731        /// <returns></returns>
2732        public static Int32 CreateTrackbar(string trackbar_name, string window_name, ref Int32 value, Int32 count, CvTrackbarCallbackHandler on_change)
2733        {
2734            return CvDll.cvCreateTrackbar(trackbar_name, window_name, ref value, count, on_change);
2735        }
2736        private static int trackbarValue = 0;
2737        #endregion
2738        #region CreateVideoWriter
2739        /// <summary>
2740        /// ビデオライタを作成し、返す.
2741        /// </summary>
2742        /// <param name="filename">出力するビデオファイルの名前</param>
2743        /// <param name="fourcc">
2744        /// フレームを圧縮するためのコーデックを表す 4 文字.例えば,"PIM1" は,MPEG-1 コーデック, "MJPG" は,motion-jpeg コーデックである.
2745        /// Win32 環境下では,null を渡すとダイアログから圧縮方法と圧縮のパラメータを選択できるようになる.
2746        /// </param>
2747        /// <param name="fps">作成されたビデオストリームのフレームレート</param>
2748        /// <param name="frame_size">ビデオフレームのサイズ</param>
2749        /// <returns>CvVideoWriter</returns>
2750        public static CvVideoWriter CreateVideoWriter(string filename, string fourcc, double fps, CvSize frame_size)
2751        {
2752            return new CvVideoWriter(filename, fourcc, fps, frame_size);
2753        }
2754        /// <summary>
2755        /// ビデオライタを作成し、返す.
2756        /// </summary>
2757        /// <param name="filename">出力するビデオファイルの名前</param>
2758        /// <param name="fourcc">
2759        /// フレームを圧縮するためのコーデックを表す 4 文字.例えば,"PIM1" は,MPEG-1 コーデック, "MJPG" は,motion-jpeg コーデックである.
2760        /// Win32 環境下では,null を渡すとダイアログから圧縮方法と圧縮のパラメータを選択できるようになる.
2761        /// </param>
2762        /// <param name="fps">作成されたビデオストリームのフレームレート</param>
2763        /// <param name="frame_size">ビデオフレームのサイズ</param>
2764        /// <param name="is_color">trueの場合,エンコーダはカラーフレームとしてエンコードする. falseの場合,グレースケールフレームとして動作する(現在のところ,このフラグは Windows でのみ利用できる).</param>
2765        /// <returns>CvVideoWriter</returns>
2766        public static CvVideoWriter CreateVideoWriter(string filename, string fourcc, double fps, CvSize frame_size, bool is_color)
2767        {
2768            return new CvVideoWriter(filename, fourcc, fps, frame_size, is_color);
2769        }
2770        #endregion
2771        #region CrossProduct
2772        /// <summary>
2773        /// 二つの3次元ベクトルの外積を計算する.
2774        /// dst = src1 × src2,  (dst1 = src12src23 - src13src22 , dst2 = src13src21 - src11src23 , dst3 = src11src22 - src12src21).
2775        /// </summary>
2776        /// <param name="src1">1番目の入力ベクトル</param>
2777        /// <param name="src2">2番目の入力ベクトル</param>
2778        /// <param name="dst">出力ベクトル</param>
2779        public static void CrossProduct(CvArr src1, CvArr src2, CvArr dst)
2780        {
2781            if (src1 == null)
2782                throw new ArgumentNullException("src1");
2783            if (src2 == null)
2784                throw new ArgumentNullException("src2");
2785            if (dst == null)
2786                throw new ArgumentNullException("dst");
2787            CvDll.cvCrossProduct(src1.CvPtr, src2.CvPtr, dst.CvPtr);
2788        }
2789        #endregion
2790        #region CvtColor
2791        /// <summary>
2792        /// 入力画像の色空間を変換する
2793        /// </summary>
2794        /// <param name="src">入力画像. 8ビット(8u), 16ビット(16u), あるいは単精度浮動小数点型(32f).</param>
2795        /// <param name="dst">出力画像. 入力画像と同じデータタイプ. チャンネル数は違うこともある.</param>
2796        /// <param name="code">色空間の変換の方法</param>
2797        public static void CvtColor(this CvArr src, CvArr dst, ColorConversion code)
2798        {
2799            if (src == null)
2800                throw new ArgumentNullException("src");
2801            if (dst == null)
2802                throw new ArgumentNullException("dst");
2803            CvDll.cvCvtColor(src.CvPtr, dst.CvPtr, code);
2804        }
2805        #endregion
2806        #region CvtSeqToArray
2807        /// <summary>
2808        /// シーケンスをメモリ内の連続した一つのブロックにコピーする
2809        /// </summary>
2810        /// <typeparam name="T"></typeparam>
2811        /// <param name="seq">シーケンス</param>
2812        /// <param name="elements">十分に大きな領域を持つ出力配列</param>
2813        /// <returns>出力される配列. outされる引数 element と同じ値.</returns>
2814        public static T[] CvtSeqToArray<T>(CvSeq seq, out T[] elements) where T : struct
2815        {
2816            return CvtSeqToArray<T>(seq, out elements, CvSlice.WholeSeq);
2817        }
2818        /// <summary>
2819        /// シーケンスをメモリ内の連続した一つのブロックにコピーする
2820        /// </summary>
2821        /// <typeparam name="T"></typeparam>
2822        /// <param name="seq">シーケンス</param>
2823        /// <param name="elements">十分に大きな領域を持つ出力配列</param>
2824        /// <param name="slice">配列へコピーするシーケンス内の部分</param>
2825        /// <returns>出力される配列. outされる引数 element と同じ値.</returns>
2826        public static T[] CvtSeqToArray<T>(CvSeq seq, out T[] elements, CvSlice slice) where T : struct
2827        {
2828            if (seq == null)
2829            {
2830                throw new ArgumentNullException("null");
2831            }
2832            elements = new T[seq.Total];
2833            using (var elementsPtr = new ArrayAddress1<T>(elements))
2834            {
2835                CvDll.cvCvtSeqToArray(seq.CvPtr, elementsPtr, slice);
2836            }
2837            return elements;
2838        }
2839        #endregion
2840        #region DecRefData
2841        /// <summary>
2842        /// 参照カウンタのポインタが null ではない場合に CvMat あるいは CvMatND のデータの参照カウンタをデクリメントし,さらにカウンタが 0 になった場合にはデータを解放する.
2843        /// </summary>
2844        /// <param name="arr">配列ヘッダ</param>
2845        public static void DecRefData(this CvArr arr)
2846        {
2847            if (arr == null)
2848            {
2849                throw new ArgumentNullException("arr");
2850            }
2851            CvInline.cvDecRefData(arr.CvPtr);
2852        }
2853        #endregion
2854        #region Det
2855        /// <summary>
2856        /// 行列式を返す
2857        /// </summary>
2858        /// <param name="mat">入力行列</param>
2859        /// <returns>行列式</returns>
2860        public static double Det(this CvArr mat)
2861        {
2862            if (mat == null)
2863            {
2864                throw new ArgumentNullException("mat");
2865            }
2866            return CvDll.cvDet(mat.CvPtr);
2867        }
2868        #endregion
2869        #region DCT
2870        /// <summary>
2871        /// 次元あるいは2次元浮動小数点型配列の順方向・逆方向離散コサイン変換を行う
2872        /// </summary>
2873        /// <param name="src">入力配列(実数の1次元あるいは2次元配列)</param>
2874        /// <param name="dst">入力と同じサイズ・タイプの出力配列</param>
2875        /// <param name="flags">変換フラグ</param>
2876        public static void DCT(this CvArr src, CvArr dst, DctFlag flags)
2877        {
2878            if (src == null)
2879                throw new ArgumentNullException("src");
2880            if (dst == null)
2881                throw new ArgumentNullException("dst");
2882            CvDll.cvDCT(src.CvPtr, dst.CvPtr, flags);
2883        }
2884        #endregion
2885        #region DeleteMoire
2886        /// <summary>
2887        /// 入力画像のモアレを削除する
2888        /// </summary>
2889        /// <param name="img">入力画像</param>
2890        public static void DeleteMoire(this IplImage img)
2891        {
2892            CvDll.cvDeleteMoire(img.CvPtr);
2893        }
2894        #endregion
2895        #region DestroyAllWindows
2896        /// <summary>
2897        /// オープンされている全ての HighGUI ウィンドウを破棄する
2898        /// </summary>
2899        public static void DestroyAllWindows()
2900        {
2901            //OpenCV.cvDestroyAllWindows();
2902            CvWindow.DestroyAllWindows();
2903        }
2904        #endregion
2905        #region DestroyWindow
2906        /// <summary>
2907        /// 指定された名前のウィンドウを破棄する
2908        /// </summary>
2909        /// <param name="name">破棄するウィンドウの名前</param>
2910        public static void DestroyWindow(string name)
2911        {
2912            CvDll.cvDestroyWindow(name);
2913        }
2914        #endregion
2915        #region DFT
2916        /// <summary>
2917        /// 1次元あるいは2次元浮動小数点型配列に対して離散フーリエ変換(DFT),逆離散フーリエ変換(IDFT)を行う.
2918        /// </summary>
2919        /// <param name="src">入力配列(実数または複素数)</param>
2920        /// <param name="dst">入力配列と同じサイズ・タイプの出力配列</param>
2921        /// <param name="flags">変換フラグ</param>
2922        public static void DFT(this CvArr src, CvArr dst, DftFlag flags)
2923        {
2924            DFT(src, dst, flags);
2925        }
2926        /// <summary>
2927        /// 1次元あるいは2次元浮動小数点型配列に対して離散フーリエ変換(DFT),逆離散フーリエ変換(IDFT)を行う.
2928        /// </summary>
2929        /// <param name="src">入力配列(実数または複素数)</param>
2930        /// <param name="dst">入力配列と同じサイズ・タイプの出力配列</param>
2931        /// <param name="flags">変換フラグ</param>
2932        /// <param name="nonzero_rows">入力配列の非0である行の数(2次元順変換の場合),あるいは出力配列で注目する行の数(2次元逆変換の場合).</param>
2933        public static void DFT(this CvArr src, CvArr dst, DftFlag flags, int nonzero_rows)
2934        {
2935            if (src == null)
2936                throw new ArgumentNullException("src");
2937            if (dst == null)
2938                throw new ArgumentNullException("dst");
2939            CvDll.cvDFT(src.CvPtr, dst.CvPtr, flags, nonzero_rows);
2940        }
2941        /// <summary>
2942        /// 1次元あるいは2次元浮動小数点型配列に対して離散フーリエ変換(DFT),逆離散フーリエ変換(IDFT)を行う. cvDFTのエイリアス.
2943        /// </summary>
2944        /// <param name="src">入力配列(実数または複素数)</param>
2945        /// <param name="dst">入力配列と同じサイズ・タイプの出力配列</param>
2946        /// <param name="flags">変換フラグ</param>
2947        public static void FFT(this CvArr src, CvArr dst, DftFlag flags)
2948        {
2949            DFT(src, dst, flags);
2950        }
2951        /// <summary>
2952        /// 1次元あるいは2次元浮動小数点型配列に対して離散フーリエ変換(DFT),逆離散フーリエ変換(IDFT)を行う.cvDFTのエイリアス.
2953        /// </summary>
2954        /// <param name="src">入力配列(実数または複素数)</param>
2955        /// <param name="dst">入力配列と同じサイズ・タイプの出力配列</param>
2956        /// <param name="flags">変換フラグ</param>
2957        /// <param name="nonzero_rows">入力配列の非0である行の数(2次元順変換の場合),あるいは出力配列で注目する行の数(2次元逆変換の場合).</param>
2958        public static void FFT(this CvArr src, CvArr dst, DftFlag flags, int nonzero_rows)
2959        {
2960            DFT(src, dst, flags, nonzero_rows);
2961        }
2962        #endregion
2963        #region Dilate
2964        /// <summary>
2965        /// 隣接ピクセルの形状を決定する指定された構造要素を用いて,入力画像を膨張する.
2966        /// この関数はインプレースモード(src=dstである入力)をサポートする.膨張は複数回 (iterations) 繰り返すことができる.
2967        /// カラー画像の場合は,それぞれのチャンネルが独立に処理される.
2968        /// </summary>
2969        /// <param name="src">入力画像</param>
2970        /// <param name="dst">出力画像</param>
2971        public static void Dilate(this CvArr src, CvArr dst)
2972        {
2973            Dilate(src, dst, null, 1);
2974        }
2975        /// <summary>
2976        /// 隣接ピクセルの形状を決定する指定された構造要素を用いて,入力画像を膨張する.
2977        /// この関数はインプレースモード(src=dstである入力)をサポートする.膨張は複数回 (iterations) 繰り返すことができる.
2978        /// カラー画像の場合は,それぞれのチャンネルが独立に処理される.
2979        /// </summary>
2980        /// <param name="src">入力画像</param>
2981        /// <param name="dst">出力画像</param>
2982        /// <param name="element">膨張に用いる構造要素.nullの場合は, 3×3 の矩形形状の構造要素を用いる.</param>
2983        public static void Dilate(this CvArr src, CvArr dst, IplConvKernel element)
2984        {
2985            Dilate(src, dst, element, 1);
2986        }
2987        /// <summary>
2988        /// 隣接ピクセルの形状を決定する指定された構造要素を用いて,入力画像を膨張する.
2989        /// この関数はインプレースモード(src=dstである入力)をサポートする.膨張は複数回 (iterations) 繰り返すことができる.
2990        /// カラー画像の場合は,それぞれのチャンネルが独立に処理される.
2991        /// </summary>
2992        /// <param name="src">入力画像</param>
2993        /// <param name="dst">出力画像</param>
2994        /// <param name="element">膨張に用いる構造要素.nullの場合は, 3×3 の矩形形状の構造要素を用いる.</param>
2995        /// <param name="iterations">膨張の回数</param>
2996        public static void Dilate(this CvArr src, CvArr dst, IplConvKernel element, int iterations)
2997        {
2998            if (src == null)
2999                throw new ArgumentNullException("src");
3000            if (dst == null)
3001                throw new ArgumentNullException("dst");
3002            IntPtr elem_ptr = (element == null) ? IntPtr.Zero : element.CvPtr;
3003            CvDll.cvDilate(src.CvPtr, dst.CvPtr, elem_ptr, iterations);
3004        }
3005        #endregion
3006        #region DistTransform
3007        /// <summary>
3008        /// 入力画像中の値が0でないピクセルから,最も近い値が0のピクセルまでの距離を計算する
3009        /// </summary>
3010        /// <param name="src">入力画像(8ビット,シングルチャンネル,2値画像)</param>
3011        /// <param name="dst">距離計算結果をピクセル値として持つ出力画像 (32ビット浮動小数点型,シングルチャンネル)</param>
3012        public static void DistTransform(this CvArr src, CvArr dst)
3013        {
3014            DistTransform(src, dst, DistanceType.L2, 3, null, null);
3015        }
3016        /// <summary>
3017        /// 入力画像中の値が0でないピクセルから,最も近い値が0のピクセルまでの距離を計算する
3018        /// </summary>
3019        /// <param name="src">入力画像(8ビット,シングルチャンネル,2値画像)</param>
3020        /// <param name="dst">距離計算結果をピクセル値として持つ出力画像 (32ビット浮動小数点型,シングルチャンネル)</param>
3021        /// <param name="distance_type">距離の種類.L1, L2, C か User</param>
3022        public static void DistTransform(this CvArr src, CvArr dst, DistanceType distance_type)
3023        {
3024            DistTransform(src, dst, distance_type, 3, null, null);
3025        }
3026        /// <summary>
3027        /// 入力画像中の値が0でないピクセルから,最も近い値が0のピクセルまでの距離を計算する
3028        /// </summary>
3029        /// <param name="src">入力画像(8ビット,シングルチャンネル,2値画像)</param>
3030        /// <param name="dst">距離計算結果をピクセル値として持つ出力画像 (32ビット浮動小数点型,シングルチャンネル)</param>
3031        /// <param name="distance_type">距離の種類.L1, L2, C か User</param>
3032        /// <param name="mask_size">距離変換マスクのサイズで,3,5,0 のいずれか. L1,C の場合,このパラメータ値は3に固定される.mask_size==0の場合,距離計算に別の近似無しアルゴリズムが用いられる.</param>
3033        public static void DistTransform(this CvArr src, CvArr dst, DistanceType distance_type, int mask_size)
3034        {
3035            DistTransform(src, dst, distance_type, mask_size, null);
3036        }
3037        /// <summary>
3038        /// 入力画像中の値が0でないピクセルから,最も近い値が0のピクセルまでの距離を計算する
3039        /// </summary>
3040        /// <param name="src">入力画像(8ビット,シングルチャンネル,2値画像)</param>
3041        /// <param name="dst">距離計算結果をピクセル値として持つ出力画像 (32ビット浮動小数点型,シングルチャンネル)</param>
3042        /// <param name="distance_type">距離の種類.L1, L2, C か User</param>
3043        /// <param name="mask_size">距離変換マスクのサイズで,3,5,0 のいずれか. L1,C の場合,このパラメータ値は3に固定される.mask_size==0の場合,距離計算に別の近似無しアルゴリズムが用いられる.</param>
3044        /// <param name="mask">ユーザ定義の距離の場合はユーザ定義のマスク.3×3のマスクを用いる場合は2つの値(上下シフト値,斜めシフト値)を指定,5×5のマスクを用いる場合は3つの値(上下シフト値,斜めシフト値,ナイト移動シフト値(桂馬飛びのシフト値))を指定する.</param>
3045        public static void DistTransform(this CvArr src, CvArr dst, DistanceType distance_type, int mask_size, float[] mask)
3046        {
3047            DistTransform(src, dst, distance_type, mask_size, mask, null);
3048        }
3049        /// <summary>
3050        /// 入力画像中の値が0でないピクセルから,最も近い値が0のピクセルまでの距離を計算する
3051        /// </summary>
3052        /// <param name="src">入力画像(8ビット,シングルチャンネル,2値画像)</param>
3053        /// <param name="dst">距離計算結果をピクセル値として持つ出力画像 (32ビット浮動小数点型,シングルチャンネル)</param>
3054        /// <param name="distance_type">距離の種類.L1, L2, C か User</param>
3055        /// <param name="mask_size">距離変換マスクのサイズで,3,5,0 のいずれか. L1,C の場合,このパラメータ値は3に固定される.mask_size==0の場合,距離計算に別の近似無しアルゴリズムが用いられる.</param>
3056        /// <param name="mask">ユーザ定義の距離の場合はユーザ定義のマスク.3×3のマスクを用いる場合は2つの値(上下シフト値,斜めシフト値)を指定,5×5のマスクを用いる場合は3つの値(上下シフト値,斜めシフト値,ナイト移動シフト値(桂馬飛びのシフト値))を指定する.</param>
3057        /// <param name="labels">オプション出力.整数ラベルに変換された2次元配列で,src ,dstと同じサイズ.現在は mask_size==3 あるいは 5 のときのみに使用される.</param>
3058        public static void DistTransform(this CvArr src, CvArr dst, DistanceType distance_type, int mask_size, float[] mask, CvArr labels)
3059        {
3060            if (src == null)
3061                throw new ArgumentNullException("src");
3062            if (dst == null)
3063                throw new ArgumentNullException("dst");
3064            IntPtr labelsPtr = (labels == null) ? IntPtr.Zero : labels.CvPtr;
3065            CvDll.cvDistTransform(src.CvPtr, dst.CvPtr, distance_type, mask_size, mask, labelsPtr);
3066        }
3067        #endregion
3068        #region Div
3069        /// <summary>
3070        /// 二つの配列の要素同士を除算する (scale=1).
3071        /// dst(I)=scale*src1(I)/src2(I) [src1!=nullの場合], 
3072        /// dst(I)=scale/src2(I) [src1=nullの場合]
3073        /// </summary>
3074        /// <param name="src1">1番目の入力配列. nullの場合は,すべての要素が 1であると仮定する.</param>
3075        /// <param name="src2">2番目の入力配列</param>
3076        /// <param name="dst">出力配列</param>
3077        public static void Div(this CvArr src1, CvArr src2, CvArr dst)
3078        {
3079            Div(src1, src2, dst, 1);
3080        }
3081        /// <summary>
3082        /// 二つの配列の要素同士を除算する.
3083        /// dst(I)=scale*src1(I)/src2(I) [src1!=nullの場合], 
3084        /// dst(I)=scale/src2(I) [src1=nullの場合]
3085        /// </summary>
3086        /// <param name="src1">1番目の入力配列. nullの場合は,すべての要素が 1であると仮定する.</param>
3087        /// <param name="src2">2番目の入力配列</param>
3088        /// <param name="dst">出力配列</param>
3089        /// <param name="scale">任意のスケーリング係数</param>
3090        public static void Div(this CvArr src1, CvArr src2, CvArr dst, double scale)
3091        {
3092            IntPtr src1Ptr = (src1 == null) ? IntPtr.Zero : src1.CvPtr;
3093            if (src2 == null)
3094                throw new ArgumentNullException("src2");
3095            if (dst == null)
3096                throw new ArgumentNullException("dst");
3097            CvDll.cvDiv(src1Ptr, src2.CvPtr, dst.CvPtr, scale);
3098        }
3099        #endregion
3100        #region DotProduct
3101        /// <summary>
3102        /// ユークリッド距離に基づく2つの配列の内積を計算する.
3103        /// src1•src2 = sumI(src1(I)*src2(I))
3104        /// </summary>
3105        /// <param name="src1">1番目の入力配列</param>
3106        /// <param name="src2">2番目の入力配列</param>
3107        /// <returns>ユークリッド距離に基づく2つの配列の内積</returns>
3108        public static double DotProduct(CvArr src1, CvArr src2)
3109        {
3110            if (src1 == null)
3111                throw new ArgumentNullException("src1");
3112            if (src2 == null)
3113                throw new ArgumentNullException("src2");
3114            return CvDll.cvDotProduct(src1.CvPtr, src2.CvPtr);
3115        }
3116        #endregion
3117        #region DrawChessboardCorners
3118            /// <summary>
3119            /// チェスボードからコーナーが完全に検出されていない場合(pattern_was_found=false)は,検出されたコーナーそれぞれに赤色の円を描く.
3120            /// また完全に検出されている場合(pattern_was_found=true)は,色付けされた各コーナを線分で接続して表示する.
3121            /// </summary>
3122            /// <param name="image">コーナー点を表示する画像.8ビットカラー画像.</param>
3123            /// <param name="pattern_size">チェスボードの各行と各列の内部コーナーの数.</param>
3124            /// <param name="corners">検出されたコーナーの配列.</param>
3125            /// <param name="pattern_was_found">チェスボードからコーナーが完全に発見された(true)か,そうでない(false)かを示す.</param>
3126            public static void DrawChessboardCorners(this CvArr image, CvSize pattern_size, CvPoint2D32f[] corners, bool pattern_was_found )
3127            {
3128            if (image == null)
3129                throw new ArgumentNullException("image");
3130            if (corners == null)
3131                throw new ArgumentNullException("corners");
3132                    CvDll.cvDrawChessboardCorners(image.CvPtr, pattern_size, corners, corners.Length, pattern_was_found);
3133            }
3134            #endregion
3135        #region DrawContours
3136        /// <summary>
3137        /// 画像の外側輪郭線,または内側輪郭線を描画する
3138        /// </summary>
3139        /// <param name="img">輪郭を描画する元画像.輪郭はROIで切り取られる.</param>
3140        /// <param name="contour">最初の輪郭へのポインタ</param>
3141        /// <param name="external_color">外側輪郭線の色</param>
3142        /// <param name="hole_color">内側輪郭線(穴)の色</param>
3143        /// <param name="max_level">描画される輪郭の最大レベル. 0にした場合,contourのみが描画される. 1にした場合,先頭の輪郭と,同レベルのすべての輪郭が描画される. 2にした場合,先頭の輪郭と同レベルのすべての輪郭と,先頭の輪郭の一つ下のレベルのすべての輪郭が描画される.以下同様.</param>
3144        public static void DrawContours(this CvArr img, CvSeq<CvPoint> contour, CvScalar external_color, CvScalar hole_color, int max_level)
3145        {
3146            DrawContours(img, contour, external_color, hole_color, max_level, 1, LineType.Link8, new CvPoint(0, 0));
3147        }
3148        /// <summary>
3149        /// 画像の外側輪郭線,または内側輪郭線を描画する
3150        /// </summary>
3151        /// <param name="img">輪郭を描画する元画像.輪郭はROIで切り取られる.</param>
3152        /// <param name="contour">最初の輪郭へのポインタ</param>
3153        /// <param name="external_color">外側輪郭線の色</param>
3154        /// <param name="hole_color">内側輪郭線(穴)の色</param>
3155        /// <param name="max_level">描画される輪郭の最大レベル. 0にした場合,contourのみが描画される. 1にした場合,先頭の輪郭と,同レベルのすべての輪郭が描画される. 2にした場合,先頭の輪郭と同レベルのすべての輪郭と,先頭の輪郭の一つ下のレベルのすべての輪郭が描画される.以下同様.</param>
3156        /// <param name="thickness">描画される輪郭線の太さ. 負(例えば=Cv.FILLED)にした場合には,内部を塗りつぶす.</param>
3157        public static void DrawContours(this CvArr img, CvSeq<CvPoint> contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness)
3158        {
3159            DrawContours(img, contour, external_color, hole_color, max_level, thickness, LineType.Link8, new CvPoint(0, 0));
3160        }
3161        /// <summary>
3162        /// 画像の外側輪郭線,または内側輪郭線を描画する
3163        /// </summary>
3164        /// <param name="img">輪郭を描画する元画像.輪郭はROIで切り取られる.</param>
3165        /// <param name="contour">最初の輪郭へのポインタ</param>
3166        /// <param name="external_color">外側輪郭線の色</param>
3167        /// <param name="hole_color">内側輪郭線(穴)の色</param>
3168        /// <param name="max_level">描画される輪郭の最大レベル. 0にした場合,contourのみが描画される. 1にした場合,先頭の輪郭と,同レベルのすべての輪郭が描画される. 2にした場合,先頭の輪郭と同レベルのすべての輪郭と,先頭の輪郭の一つ下のレベルのすべての輪郭が描画される.以下同様.</param>
3169        /// <param name="thickness">描画される輪郭線の太さ. 負(例えば=Cv.FILLED)にした場合には,内部を塗りつぶす.</param>
3170        /// <param name="line_type">線の種類</param>
3171        public static void DrawContours(this CvArr img, CvSeq<CvPoint> contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness, LineType line_type)
3172        {
3173            DrawContours(img, contour, external_color, hole_color, max_level, thickness, line_type, new CvPoint(0, 0));
3174        }
3175        /// <summary>
3176        /// 画像の外側輪郭線,または内側輪郭線を描画する
3177        /// </summary>
3178        /// <param name="img">輪郭を描画する元画像.輪郭はROIで切り取られる.</param>
3179        /// <param name="contour">最初の輪郭へのポインタ</param>
3180        /// <param name="external_color">外側輪郭線の色</param>
3181        /// <param name="hole_color">内側輪郭線(穴)の色</param>
3182        /// <param name="max_level">描画される輪郭の最大レベル. 0にした場合,contourのみが描画される. 1にした場合,先頭の輪郭と,同レベルのすべての輪郭が描画される. 2にした場合,先頭の輪郭と同レベルのすべての輪郭と,先頭の輪郭の一つ下のレベルのすべての輪郭が描画される.以下同様.</param>
3183        /// <param name="thickness">描画される輪郭線の太さ. 負(例えば=Cv.FILLED)にした場合には,内部を塗りつぶす.</param>
3184        /// <param name="line_type">線の種類</param>
3185        /// <param name="offset">全ての座標を指定した値だけシフトする</param>
3186        public static void DrawContours(this CvArr img, CvSeq<CvPoint> contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness, LineType line_type, CvPoint offset)
3187        {
3188            if (img == null)
3189                throw new ArgumentNullException("img");
3190            if (contour == null)
3191                throw new ArgumentNullException("contour");
3192            CvDll.cvDrawContours(img.CvPtr, contour.CvPtr, external_color, hole_color, max_level, thickness, line_type, offset);
3193        }
3194        #endregion
3195        #region EigenVV
3196        /// <summary>
3197        /// 対称行列の固有値と固有ベクトルを計算する
3198        /// </summary>
3199        /// <param name="mat">入力対称正方行列.処理中に変更される.</param>
3200        /// <param name="evects">固有ベクトルの出力行列.連続した行として保存される. </param>
3201        /// <param name="evals">固有値ベクトルの出力ベクトル.降順に保存される(もちろん固有値と固有ベクトルの順番は一致する).</param>
3202        public static void EigenVV(this CvArr mat, CvArr evects, CvArr evals)
3203        {
3204            EigenVV(mat, evects, evals, 0);
3205        }
3206        /// <summary>
3207        /// 対称行列の固有値と固有ベクトルを計算する
3208        /// </summary>
3209        /// <param name="mat">入力対称正方行列.処理中に変更される.</param>
3210        /// <param name="evects">固有ベクトルの出力行列.連続した行として保存される. </param>
3211        /// <param name="evals">固有値ベクトルの出力ベクトル.降順に保存される(もちろん固有値と固有ベクトルの順番は一致する).</param>
3212        /// <param name="eps">対角化の精度(一般的に,DBL_EPSILON=≈10^-15 で十分である)</param>
3213        public static void EigenVV(this CvArr mat, CvArr evects, CvArr evals, double eps)
3214        {
3215            if (mat == null)
3216                throw new ArgumentNullException("mat");
3217            if (evects == null)
3218                throw new ArgumentNullException("evects");
3219            if (evals == null)
3220                throw new ArgumentNullException("evals");
3221            CvDll.cvEigenVV(mat.CvPtr, evects.CvPtr, evals.CvPtr, eps);
3222        }
3223        #endregion
3224        #region Ellipse
3225        /// <summary>
3226        /// 枠だけの楕円,楕円弧,もしくは塗りつぶした楕円を描画する.
3227        /// 描画される楕円はROIによって切り取られる.
3228        /// アンチエイリアスされた線や太い線を指定した場合には,線形近似が用いられる.
3229        /// </summary>
3230        /// <param name="img">楕円が描画される画像</param>
3231        /// <param name="center">楕円の中心</param>
3232        /// <param name="axes">楕円の軸の長さ</param>
3233        /// <param name="angle">回転角度</param>
3234        /// <param name="start_angle">楕円弧の開始角度</param>
3235        /// <param name="end_angle">楕円弧の終了角度</param>
3236        /// <param name="color">楕円の色</param>
3237        public static void Ellipse(this CvArr img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color)
3238        {
3239            Ellipse(img, center, axes, angle, start_angle, end_angle, color, 1, LineType.Link8, 0);
3240        }
3241        /// <summary>
3242        /// 枠だけの楕円,楕円弧,もしくは塗りつぶした楕円を描画する.
3243        /// 描画される楕円はROIによって切り取られる.
3244        /// アンチエイリアスされた線や太い線を指定した場合には,線形近似が用いられる.
3245        /// </summary>
3246        /// <param name="img">楕円が描画される画像</param>
3247        /// <param name="center">楕円の中心</param>
3248        /// <param name="axes">楕円の軸の長さ</param>
3249        /// <param name="angle">回転角度</param>
3250        /// <param name="start_angle">楕円弧の開始角度</param>
3251        /// <param name="end_angle">楕円弧の終了角度</param>
3252        /// <param name="color">楕円の色</param>
3253        /// <param name="thickness">楕円弧の線の幅</param>
3254        public static void Ellipse(this CvArr img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness)
3255        {
3256            Ellipse(img, center, axes, angle, start_angle, end_angle, color, thickness, LineType.Link8, 0);
3257        }
3258        /// <summary>
3259        /// 枠だけの楕円,楕円弧,もしくは塗りつぶした楕円を描画する.
3260        /// 描画される楕円はROIによって切り取られる.
3261        /// アンチエイリアスされた線や太い線を指定した場合には,線形近似が用いられる.
3262        /// </summary>
3263        /// <param name="img">楕円が描画される画像</param>
3264        /// <param name="center">楕円の中心</param>
3265        /// <param name="axes">楕円の軸の長さ</param>
3266        /// <param name="angle">回転角度</param>
3267        /// <param name="start_angle">楕円弧の開始角度</param>
3268        /// <param name="end_angle">楕円弧の終了角度</param>
3269        /// <param name="color">楕円の色</param>
3270        /// <param name="thickness">楕円弧の線の幅</param>
3271        /// <param name="line_type">楕円弧の線の種類</param>
3272        public static void Ellipse(this CvArr img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, LineType line_type)
3273        {
3274            Ellipse(img, center, axes, angle, start_angle, end_angle, color, thickness, line_type, 0);
3275        }
3276        /// <summary>
3277        /// 枠だけの楕円,楕円弧,もしくは塗りつぶした楕円を描画する.
3278        /// 描画される楕円はROIによって切り取られる.
3279        /// アンチエイリアスされた線や太い線を指定した場合には,線形近似が用いられる.
3280        /// </summary>
3281        /// <param name="img">楕円が描画される画像</param>
3282        /// <param name="center">楕円の中心</param>
3283        /// <param name="axes">楕円の軸の長さ</param>
3284        /// <param name="angle">回転角度</param>
3285        /// <param name="start_angle">楕円弧の開始角度</param>
3286        /// <param name="end_angle">楕円弧の終了角度</param>
3287        /// <param name="color">楕円の色</param>
3288        /// <param name="thickness">楕円弧の線の幅</param>
3289        /// <param name="line_type">楕円弧の線の種類</param>
3290        /// <param name="shift">中心座標と軸の長さの小数点以下の桁を表すビット数</param>
3291        public static void Ellipse(this CvArr img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, LineType line_type, int shift)
3292        {
3293            if (img == null)
3294            {
3295                throw new ArgumentNullException("img");
3296            }
3297            CvDll.cvEllipse(img.CvPtr, center, axes, angle, start_angle, end_angle, color, thickness, line_type, shift);
3298        }
3299        #endregion
3300        #region EndFindContours
3301#if LANG_JA
3302        /// <summary>
3303        /// 輪郭走査処理を終了する
3304        /// </summary>
3305        /// <param name="scanner">輪郭スキャナへのポインタ</param>
3306        /// <returns></returns>
3307#else
3308        /// <summary>
3309        /// Finishes scanning process
3310        /// </summary>
3311        /// <param name="scanner">Contour scanner. </param>
3312        /// <returns></returns>
3313#endif
3314        public static CvSeq<CvPoint> EndFindContours(this CvContourScanner scanner)
3315        {
3316            if (scanner == null)
3317            {
3318                throw new ArgumentNullException("scanner");
3319            }
3320
3321            IntPtr ptr = scanner.CvPtr;
3322            IntPtr result = CvDll.cvEndFindContours(ref ptr);
3323            scanner.IsDisposed = true;
3324            if (result == IntPtr.Zero)
3325                return null;
3326            else
3327                return new CvSeq<CvPoint>(result);
3328        }
3329        #endregion
3330        #region EndWriteStruct
3331        /// <summary>
3332        /// ファイルストレージへの構造体の書き込みを終了する.
3333        /// </summary>
3334        /// <param name="fs">ファイルストレージ</param>
3335        public static void EndWriteStruct(this CvFileStorage fs)
3336        {
3337            if (fs == null)
3338            {
3339                throw new ArgumentNullException("fs");
3340            }
3341            CvDll.cvEndWriteStruct(fs.CvPtr);
3342        }
3343        #endregion
3344        #region EqualizeHist
3345        /// <summary>
3346        /// グレースケール画像のヒストグラムを均一化する.輝度を均一化し,画像のコントラストを上げる.
3347        /// </summary>
3348        /// <param name="src">入力画像.8ビットシングルチャンネル. </param>
3349        /// <param name="dst">出力画像.srcと同じサイズ, 同じデータタイプ.</param>
3350        public static void EqualizeHist(this CvArr src, CvArr dst)
3351        {
3352            if (src == null)
3353                throw new ArgumentNullException("src");
3354            if (dst == null)
3355                throw new ArgumentNullException("dst");
3356            CvDll.cvEqualizeHist(src.CvPtr, dst.CvPtr);
3357        }
3358        #endregion
3359        #region Erode
3360        /// <summary>
3361        /// 隣接ピクセルの形状を決定する指定された構造要素を用いて,入力画像を収縮する.
3362        /// この関数はインプレースモード(src=dstである入力)をサポートする.収縮は複数回 (iterations) 繰り返すことができる.
3363        /// カラー画像の場合は,それぞれのチャンネルが独立に処理される.
3364        /// </summary>
3365        /// <param name="src">入力画像</param>
3366        /// <param name="dst">出力画像</param>
3367        public static void Erode(this CvArr src, CvArr dst)
3368        {
3369            Erode(src, dst, null);
3370        }
3371        /// <summary>
3372        /// 隣接ピクセルの形状を決定する指定された構造要素を用いて,入力画像を収縮する.
3373        /// この関数はインプレースモード(src=dstである入力)をサポートする.収縮は複数回 (iterations) 繰り返すことができる.
3374        /// カラー画像の場合は,それぞれのチャンネルが独立に処理される.
3375        /// </summary>
3376        /// <param name="src">入力画像</param>
3377        /// <param name="dst">出力画像</param>
3378        /// <param name="element">収縮に用いる構造要素.nullの場合は, 3×3 の矩形形状の構造要素を用いる.</param>
3379        public static void Erode(this CvArr src, CvArr dst, IplConvKernel element)
3380        {
3381            Erode(src, dst, element, 1);
3382        }
3383        /// <summary>
3384        /// 隣接ピクセルの形状を決定する指定された構造要素を用いて,入力画像を収縮する.
3385        /// この関数はインプレースモード(src=dstである入力)をサポートする.収縮は複数回 (iterations) 繰り返すことができる.
3386        /// カラー画像の場合は,それぞれのチャンネルが独立に処理される.
3387        /// </summary>
3388        /// <param name="src">入力画像</param>
3389        /// <param name="dst">出力画像</param>
3390        /// <param name="element">収縮に用いる構造要素.nullの場合は, 3×3 の矩形形状の構造要素を用いる.</param>
3391        /// <param name="iterations">収縮の回数</param>
3392        public static void Erode(this CvArr src, CvArr dst, IplConvKernel element, int iterations)
3393        {
3394            if (src == null)
3395                throw new ArgumentNullException("src");
3396            if (dst == null)
3397                throw new ArgumentNullException("dst");
3398            IntPtr elem_ptr = (element == null) ? IntPtr.Zero : element.CvPtr;
3399            CvDll.cvErode(src.CvPtr, dst.CvPtr, elem_ptr, iterations);
3400        }
3401        #endregion
3402        #region Exp
3403        /// <summary>
3404        /// 入力配列のすべての要素に対して,それを指数とする自然対数の底eのべき乗を求める.
3405        /// dst(I) = exp(src(I)).
3406        /// 最大相対誤差は≈7e-6.現在,この関数は,指数表現されない(denormalize)値を出力時に0に変換する.
3407        /// </summary>
3408        /// <param name="src">入力配列</param>
3409        /// <param name="dst">出力配列.倍精度の浮動小数点型(double),または入力配列と同じタイプでなければならない.</param>
3410        public static void Exp(this CvArr src, CvArr dst)
3411        {
3412            if (src == null)
3413                throw new ArgumentNullException("src");
3414            if (dst == null)
3415                throw new ArgumentNullException("dst");
3416            CvDll.cvExp(src.CvPtr, dst.CvPtr);
3417        }
3418        #endregion
3419        #region ExtractSURF
3420        /// <summary>
3421        /// 画像中からSURF(Speeded Up Robust Features)を検出する
3422        /// </summary>
3423        /// <param name="image">8ビット,グレースケールの入力画像. </param>
3424        /// <param name="mask">オプション:8ビットのマスク画像.非0 のマスクピクセルが50%以上を占める領域からのみ,特徴点検出を行う.</param>
3425        /// <param name="keypoints">出力パラメータ.キーポイントのシーケンスへのポインタのポインタ. これは,CvSURFPoint 構造体のシーケンスになる</param>
3426        /// <param name="descriptors">オプション:出力パラメータ.ディスクリプタのシーケンスへのポインタのポインタ. シーケンスの各要素は,params.extended の値に依存して, 64-要素,あるいは 128-要素の浮動小数点数(CV_32F)ベクトルとなる. パラメータが NULL の場合,ディスクリプタは計算されない.</param>
3427        /// <param name="storage">キーポイントとディスクリプタが格納されるメモリストレージ</param>
3428        /// <param name="param">CvSURFParams 構造体に入れられた,様々なアルゴリズムパラメータ</param>
3429        public static void ExtractSURF(this CvArr image, CvArr mask, out CvSeq<CvSURFPoint> keypoints, out CvSeq<float> descriptors, CvMemStorage storage, CvSURFParams param)
3430        {
3431            if (image == null)
3432                throw new ArgumentNullException("img");
3433            if (storage == null)
3434                throw new ArgumentNullException("img");
3435
3436            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
3437            IntPtr keypointsPtr = IntPtr.Zero;
3438            IntPtr descriptorsPtr = IntPtr.Zero;
3439
3440            CvDll.cvExtractSURF(image.CvPtr, maskPtr, out keypointsPtr, out descriptorsPtr, storage.CvPtr, param);
3441
3442            keypoints = new CvSeq<CvSURFPoint>(keypointsPtr);
3443            descriptors = new CvSeq<float>(descriptorsPtr);
3444        }
3445        #endregion
3446        #region FastArctan
3447        /// <summary>
3448        /// 入力された2次元ベクトルの角度を計算する.角度は度(degree)単位で扱われ,0°から360°の範囲で変化する.精度は ~0.1°.
3449        /// </summary>
3450        /// <param name="y">2次元ベクトルのy座標</param>
3451        /// <param name="x">2次元ベクトルのx座標</param>
3452        /// <returns></returns>
3453        public static float FastArctan(float y, float x)
3454        {
3455            return CvDll.cvFastArctan(y, x);
3456        }
3457        #endregion
3458        #region FillConvexPoly
3459        /// <summary>
3460        /// 凸ポリゴンの内部を塗りつぶす.この関数は,関数cvFillPolyより高速に動作する.
3461        /// また,凸ポリゴンだけでなく,その輪郭が水平なスキャンラインと2回以下しか交差しないような単純なポリゴンはすべて塗りつぶすことができる.
3462        /// </summary>
3463        /// <param name="img">ポリゴンが描かれる画像</param>
3464        /// <param name="pts">一つのポリゴンへのポインタの配列</param>
3465        /// <param name="color">ポリゴンの色</param>
3466        public static void FillConvexPoly(this CvArr img, CvPoint[] pts, CvScalar color)
3467        {
3468            FillConvexPoly(img, pts, color, LineType.Link8, 0);
3469        }
3470        /// <summary>
3471        /// 凸ポリゴンの内部を塗りつぶす.この関数は,関数cvFillPolyより高速に動作する.
3472        /// また,凸ポリゴンだけでなく,その輪郭が水平なスキャンラインと2回以下しか交差しないような単純なポリゴンはすべて塗りつぶすことができる.
3473        /// </summary>
3474        /// <param name="img">ポリゴンが描かれる画像</param>
3475        /// <param name="pts">一つのポリゴンへのポインタの配列</param>
3476        /// <param name="color">ポリゴンの色</param>
3477        /// <param name="line_type">線の種類</param>
3478        public static void FillConvexPoly(this CvArr img, CvPoint[] pts, CvScalar color, LineType line_type)
3479        {
3480            FillConvexPoly(img, pts, color, line_type, 0);
3481        }
3482        /// <summary>
3483        /// 凸ポリゴンの内部を塗りつぶす.この関数は,関数cvFillPolyより高速に動作する.
3484        /// また,凸ポリゴンだけでなく,その輪郭が水平なスキャンラインと2回以下しか交差しないような単純なポリゴンはすべて塗りつぶすことができる.
3485        /// </summary>
3486        /// <param name="img">ポリゴンが描かれる画像</param>
3487        /// <param name="pts">一つのポリゴンへのポインタの配列</param>
3488        /// <param name="color">ポリゴンの色</param>
3489        /// <param name="line_type">線の種類</param>
3490        /// <param name="shift">頂点座標の小数点以下の桁を表すビット数</param>
3491        public static void FillConvexPoly(this CvArr img, CvPoint[] pts, CvScalar color, LineType line_type, int shift)
3492        {
3493            if (img == null)
3494                throw new ArgumentNullException("img");
3495            if (pts == null)
3496                throw new ArgumentNullException("pts");
3497            if (pts.Length == 0)
3498                throw new ArgumentException();
3499            CvDll.cvFillConvexPoly(img.CvPtr, pts, pts.Length, color, line_type, shift);
3500        }
3501        #endregion
3502        #region Filter2D
3503        /// <summary>
3504        /// 画像に線形フィルタを適用する
3505        /// </summary>
3506        /// <param name="src">入力画像</param>
3507        /// <param name="dst">出力画像</param>
3508        /// <param name="kernel">フィルタマスク.係数のシングルチャンネルの2次元浮動小数点型行列.</param>
3509        public static void Filter2D(this CvArr src, CvArr dst, CvMat kernel)
3510        {
3511            Filter2D(src, dst, kernel, new CvPoint(-1, -1));
3512        }
3513        /// <summary>
3514        /// 画像に線形フィルタを適用する
3515        /// </summary>
3516        /// <param name="src">入力画像</param>
3517        /// <param name="dst">出力画像</param>
3518        /// <param name="kernel">フィルタマスク.係数のシングルチャンネルの2次元浮動小数点型行列.</param>
3519        /// <param name="anchor">カーネルのアンカー.カーネルマスクでカバーされる隣接領域内における, フィルタ対象となるピクセルの相対位置を表す.</param>
3520        public static void Filter2D(this CvArr src, CvArr dst, CvMat kernel, CvPoint anchor)
3521        {
3522            if (src == null)
3523                throw new ArgumentNullException("src");
3524            if (dst == null)
3525                throw new ArgumentNullException("dst");
3526            if (kernel == null)
3527                throw new ArgumentNullException("kernel");
3528            CvDll.cvFilter2D(src.CvPtr, dst.CvPtr, kernel.CvPtr, anchor);
3529        }
3530        #endregion
3531        #region FindChessboardCorners
3532        /// <summary>
3533        /// 入力画像がチェスボードパターンであるかどうかを確認し,チェスボードの各コーナーの位置検出を試みる.
3534        /// </summary>
3535        /// <param name="image">入力のチェスボード画像.8ビットのグレースケールまたはカラー画像.</param>
3536        /// <param name="pattern_size">チェスボードの行と列ごとのコーナーの数</param>
3537        /// <param name="corners">検出されたコーナーの配列. Length=pattern_size.Width*pattern_size.Height</param>
3538        /// <returns>すべてのコーナーが検出され,正しい順番(行順で,かつ各行は左から右に並ぶ)でそれらが配置されている場合には, true</returns>
3539        public static bool FindChessboardCorners(this CvArr image, CvSize pattern_size, out CvPoint2D32f[] corners)
3540        {
3541            int corner_count;
3542            return FindChessboardCorners(image, pattern_size, out corners, out corner_count, ChessboardFlag.AdaptiveThresh | ChessboardFlag.NormalizeImage);
3543        }
3544        /// <summary>
3545        /// 入力画像がチェスボードパターンであるかどうかを確認し,チェスボードの各コーナーの位置検出を試みる.
3546        /// </summary>
3547        /// <param name="image">入力のチェスボード画像.8ビットのグレースケールまたはカラー画像.</param>
3548        /// <param name="pattern_size">チェスボードの行と列ごとのコーナーの数</param>
3549        /// <param name="corners">検出されたコーナーの配列. Length=pattern_size.Width*pattern_size.Height</param>
3550        /// <param name="corner_count">コーナーの数が出力される</param>
3551        /// <returns>すべてのコーナーが検出され,正しい順番(行順で,かつ各行は左から右に並ぶ)でそれらが配置されている場合には, true</returns>
3552        public static bool FindChessboardCorners(this CvArr image, CvSize pattern_size, out CvPoint2D32f[] corners, out int corner_count)
3553        {
3554            return FindChessboardCorners(image, pattern_size, out corners, out corner_count, ChessboardFlag.AdaptiveThresh | ChessboardFlag.NormalizeImage);
3555        }
3556        /// <summary>
3557        /// 入力画像がチェスボードパターンであるかどうかを確認し,チェスボードの各コーナーの位置検出を試みる.
3558        /// </summary>
3559        /// <param name="image">入力のチェスボード画像.8ビットのグレースケールまたはカラー画像.</param>
3560        /// <param name="pattern_size">チェスボードの行と列ごとのコーナーの数</param>
3561        /// <param name="corners">検出されたコーナーの配列. Length=pattern_size.Width*pattern_size.Height</param>
3562        /// <param name="corner_count">コーナーの数が出力される</param>
3563        /// <param name="flags">処理フラグ</param>
3564        /// <returns>すべてのコーナーが検出され,正しい順番(行順で,かつ各行は左から右に並ぶ)でそれらが配置されている場合には, true</returns>
3565        public static bool FindChessboardCorners(this CvArr image, CvSize pattern_size, out CvPoint2D32f[] corners, out int corner_count, ChessboardFlag flags)
3566        {
3567            if (image == null)
3568            {
3569                throw new ArgumentNullException("image");
3570            }
3571
3572            corner_count = pattern_size.Width * pattern_size.Height;
3573            corners = new CvPoint2D32f[corner_count];
3574
3575            using (ArrayAddress1<CvPoint2D32f> cornersPtr = new ArrayAddress1<CvPoint2D32f>(corners))
3576            {
3577                int result = CvDll.cvFindChessboardCorners(image.CvPtr, pattern_size, cornersPtr, ref corner_count, flags);
3578                return result != 0;
3579            }
3580        }
3581        #endregion
3582        #region FindContours
3583        /// <summary>
3584        /// 2値画像中の輪郭を見つける
3585        /// </summary>
3586        /// <param name="image">入力画像(8ビットシングルチャンネル).値が0以外のピクセルは「1」,0のピクセルは「0」とする.</param>
3587        /// <param name="storage">抽出された輪郭を保存する領域</param>
3588        /// <param name="first_contour">出力パラメータ.一番外側の輪郭へのポインタが入っている.</param>
3589        /// <returns>抽出した輪郭の個数</returns>
3590        public static int FindContours(this CvArr image, CvMemStorage storage, out CvSeq<CvPoint> first_contour)
3591        {
3592            return FindContours(image, storage, out first_contour, CvContour<CvPoint>.SizeOf, ContourRetrieval.List, ContourChain.ApproxSimple, new CvPoint(0, 0));
3593        }
3594        /// <summary>
3595        /// 2値画像中の輪郭を見つける
3596        /// </summary>
3597        /// <param name="image">入力画像(8ビットシングルチャンネル).値が0以外のピクセルは「1」,0のピクセルは「0」とする.</param>
3598        /// <param name="storage">抽出された輪郭を保存する領域</param>
3599        /// <param name="first_contour">出力パラメータ.一番外側の輪郭へのポインタが入っている.</param>
3600        /// <param name="header_size">シーケンスヘッダのサイズ.method=CV_CHAIN_CODEの場合,>=sizeof(CvChain) ,それ以外の場合 >=sizeof(CvContour).</param>
3601        /// <returns>抽出した輪郭の個数</returns>
3602        public static int FindContours(this  CvArr image, CvMemStorage storage, out CvSeq<CvPoint> first_contour, int header_size)
3603        {
3604            return FindContours(image, storage, out first_contour, header_size, ContourRetrieval.List, ContourChain.ApproxSimple, new CvPoint(0, 0));
3605        }
3606        /// <summary>
3607        /// 2値画像中の輪郭を見つける
3608        /// </summary>
3609        /// <param name="image">入力画像(8ビットシングルチャンネル).値が0以外のピクセルは「1」,0のピクセルは「0」とする.</param>
3610        /// <param name="storage">抽出された輪郭を保存する領域</param>
3611        /// <param name="first_contour">出力パラメータ.一番外側の輪郭へのポインタが入っている.</param>
3612        /// <param name="header_size">シーケンスヘッダのサイズ.method=CV_CHAIN_CODEの場合,>=sizeof(CvChain) ,それ以外の場合 >=sizeof(CvContour).</param>
3613        /// <param name="mode">抽出モード </param>
3614        /// <returns>抽出した輪郭の個数</returns>
3615        public static int FindContours(this  CvArr image, CvMemStorage storage, out CvSeq<CvPoint> first_contour, int header_size, ContourRetrieval mode)
3616        {
3617            return FindContours(image, storage, out first_contour, header_size, mode, ContourChain.ApproxSimple, new CvPoint(0, 0));
3618        }
3619        /// <summary>
3620        /// 2値画像中の輪郭を見つける
3621        /// </summary>
3622        /// <param name="image">入力画像(8ビットシングルチャンネル).値が0以外のピクセルは「1」,0のピクセルは「0」とする.</param>
3623        /// <param name="storage">抽出された輪郭を保存する領域</param>
3624        /// <param name="first_contour">出力パラメータ.一番外側の輪郭へのポインタが入っている.</param>
3625        /// <param name="header_size">シーケンスヘッダのサイズ.method=CV_CHAIN_CODEの場合,>=sizeof(CvChain) ,それ以外の場合 >=sizeof(CvContour).</param>
3626        /// <param name="mode">抽出モード </param>
3627        /// <param name="method">近似手法</param>
3628        /// <returns>抽出した輪郭の個数</returns>
3629        public static int FindContours(this  CvArr image, CvMemStorage storage, out CvSeq<CvPoint> first_contour, int header_size, ContourRetrieval mode, ContourChain method)
3630        {
3631            return FindContours(image, storage, out first_contour, header_size, mode, method, new CvPoint(0, 0));
3632        }
3633        /// <summary>
3634        /// 2値画像中の輪郭を見つける
3635        /// </summary>
3636        /// <param name="image">入力画像(8ビットシングルチャンネル).値が0以外のピクセルは「1」,0のピクセルは「0」とする.</param>
3637        /// <param name="storage">抽出された輪郭を保存する領域</param>
3638        /// <param name="first_contour">出力パラメータ.一番外側の輪郭へのポインタが入っている.</param>
3639        /// <param name="header_size">シーケンスヘッダのサイズ.method=CV_CHAIN_CODEの場合,>=sizeof(CvChain) ,それ以外の場合 >=sizeof(CvContour).</param>
3640        /// <param name="mode">抽出モード </param>
3641        /// <param name="method">近似手法</param>
3642        /// <param name="offset">オフセット.全ての輪郭点はこれによってシフトされる.</param>
3643        /// <returns>抽出した輪郭の個数</returns>
3644        public static int FindContours(this CvArr image, CvMemStorage storage, out CvSeq<CvPoint> first_contour, int header_size, ContourRetrieval mode, ContourChain method, CvPoint offset)
3645        {
3646            if (image == null)
3647                throw new ArgumentNullException("image");
3648            if (storage == null)
3649                throw new ArgumentNullException("storage");
3650
3651            IntPtr first_contour_ptr = IntPtr.Zero;
3652            Int32 result = CvDll.cvFindContours(image.CvPtr, storage.CvPtr, ref first_contour_ptr, header_size, mode, method, offset);
3653
3654            if (first_contour_ptr == IntPtr.Zero)
3655            {
3656                first_contour = null;
3657            }
3658            else if (method == ContourChain.Code)
3659            {
3660                first_contour = new CvChain<CvPoint>(first_contour_ptr);
3661            }
3662            else
3663            {
3664                first_contour = new CvContour<CvPoint>(first_contour_ptr);
3665            }
3666            return result;
3667        }
3668        #endregion
3669        #region FindCornerSubPix
3670        /// <summary>
3671        /// コーナー位置を高精度化する.
3672        /// </summary>
3673        /// <param name="image">入力画像</param>
3674        /// <param name="corners">コーナーの初期座標が入力され,高精度化された座標が出力される.</param>
3675        /// <param name="count">コーナーの数</param>
3676        /// <param name="win">検索ウィンドウの半分のサイズ.(例)win=(5,5) ならば 5*2+1 × 5*2+1 = 11 × 11 が探索ウィンドウして使われる.</param>
3677        /// <param name="zero_zone">総和を計算する際に含まれない,探索領域の中心に存在する総和対象外領域の半分のサイズ.この値は,自己相関行列において発生しうる特異点を避けるために用いられる. 値が (-1,-1) の場合は,そのようなサイズはないということを意味する</param>
3678        /// <param name="criteria">コーナー座標の高精度化のための繰り返し処理の終了条件.コーナー位置の高精度化の繰り返し処理は,規定回数に達するか,目標精度に達したときに終了する.</param>
3679        public static void FindCornerSubPix(this CvArr image, CvPoint2D32f[] corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria)
3680        {
3681            if (image == null)
3682                throw new ArgumentNullException("image");
3683            if (corners == null)
3684                throw new ArgumentNullException("corners");
3685
3686            //using (ArrayAddress1<CvPoint2D32f> cornersPtr = new ArrayAddress1<CvPoint2D32f>(corners))
3687            //{
3688            CvDll.cvFindCornerSubPix(image.CvPtr, corners, count, win, zero_zone, criteria);
3689            //}
3690        }
3691        #endregion
3692        #region FindExtrinsicCameraParams2
3693        /// <summary>
3694        /// 既知の内部パラメータを用いて,それぞれのビューにおける外部パラメータを推定する.
3695        /// 3次元のオブジェクトの点とそれに対応する2次元投影点が指定されなければならない.この関数も逆投影誤差の最小化を行う.
3696        /// </summary>
3697        /// <param name="object_points">オブジェクトの点の配列.3xNまたはNx3でNはビューにおける点の数.</param>
3698        /// <param name="image_points">対応する画像上の点の配列.2xNまたはNx2でNはビューにおける点の数.</param>
3699        /// <param name="intrinsic_matrix">カメラ内部行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. </param>
3700        /// <param name="distortion_coeffs">歪み係数のベクトル.4x1または1x4 [k1, k2, p1, p2].NULLの場合,歪み係数はすべて0 であるとする.</param>
3701        /// <param name="rotation_vector">出力される 3x1 の回転ベクトル</param>
3702        /// <param name="translation_vector">出力される 3x1 の並進ベクトル</param>
3703        public static void FindExtrinsicCameraParams2(CvMat object_points, CvMat image_points, CvMat intrinsic_matrix, CvMat distortion_coeffs, out CvMat rotation_vector, out CvMat translation_vector)
3704        {
3705            if (object_points == null)
3706                throw new ArgumentNullException("object_points");
3707            if (image_points == null)
3708                throw new ArgumentNullException("image_points");
3709            if (intrinsic_matrix == null)
3710                throw new ArgumentNullException("intrinsic_matrix");
3711            if (distortion_coeffs == null)
3712                throw new ArgumentNullException("distortion_coeffs");
3713            IntPtr rotation_ptr = CvDll.cvCreateMat(3, 1, MatrixType.F32C1);
3714            IntPtr translation_ptr = CvDll.cvCreateMat(3, 1, MatrixType.F32C1);
3715            CvDll.cvFindExtrinsicCameraParams2(object_points.CvPtr, image_points.CvPtr, intrinsic_matrix.CvPtr, distortion_coeffs.CvPtr, rotation_ptr, translation_ptr);
3716            rotation_vector = (rotation_ptr == IntPtr.Zero) ? null : new CvMat(rotation_ptr);
3717            translation_vector = (translation_ptr == IntPtr.Zero) ? null : new CvMat(translation_ptr);
3718        }
3719        #endregion
3720        #region FindFundamentalMat
3721        /// <summary>
3722        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
3723        /// </summary>
3724        /// <param name="points1">大きさが2xN, Nx2, 3xN,または Nx3 の1枚目の画像上の点の配列 (N は点の数).マルチチャンネルで大きさ 1xN,または Nx1 の配 列も使用可能である. 点の座標は浮動小数点型で表される(単精度または倍精度).</param>
3725        /// <param name="points2">2枚目の画像上の点の配列で point1とフォーマットやサイズは同じ.</param>
3726        /// <param name="fundamental_matrix">出力される基礎行列.サイズは 3x3, または 9x3(7-point methodは3つの行列を返す).</param>
3727        /// <returns>求めた基礎行列の数(1 または 3).もし行列が求まらないときは0.</returns>
3728        public static int FindFundamentalMat(CvMat points1, CvMat points2, CvMat fundamental_matrix)
3729        {
3730            return FindFundamentalMat(points1, points2, fundamental_matrix, FundamentalMatMethod.Ransac, 3.0, 0.99, null);
3731        }
3732        /// <summary>
3733        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
3734        /// </summary>
3735        /// <param name="points1">大きさが2xN, Nx2, 3xN,または Nx3 の1枚目の画像上の点の配列 (N は点の数).マルチチャンネルで大きさ 1xN,または Nx1 の配 列も使用可能である. 点の座標は浮動小数点型で表される(単精度または倍精度).</param>
3736        /// <param name="points2">2枚目の画像上の点の配列で point1とフォーマットやサイズは同じ.</param>
3737        /// <param name="fundamental_matrix">出力される基礎行列.サイズは 3x3, または 9x3(7-point methodは3つの行列を返す).</param>
3738        /// <param name="method">基礎行列の計算手法</param>
3739        /// <returns>求めた基礎行列の数(1 または 3).もし行列が求まらないときは0.</returns>
3740        public static int FindFundamentalMat(CvMat points1, CvMat points2, CvMat fundamental_matrix, FundamentalMatMethod method)
3741        {
3742            return FindFundamentalMat(points1, points2, fundamental_matrix, method, 3.0, 0.99, null);
3743        }
3744        /// <summary>
3745        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
3746        /// </summary>
3747        /// <param name="points1">大きさが2xN, Nx2, 3xN,または Nx3 の1枚目の画像上の点の配列 (N は点の数).マルチチャンネルで大きさ 1xN,または Nx1 の配 列も使用可能である. 点の座標は浮動小数点型で表される(単精度または倍精度).</param>
3748        /// <param name="points2">2枚目の画像上の点の配列で point1とフォーマットやサイズは同じ.</param>
3749        /// <param name="fundamental_matrix">出力される基礎行列.サイズは 3x3, または 9x3(7-point methodは3つの行列を返す).</param>
3750        /// <param name="method">基礎行列の計算手法</param>
3751        /// <param name="param1">RANSAC メソッドのときにのみ使用されるパラメータ.点からエピポーラ線までの最大距離(その距離を超えるものは外れ値であると判断し,それらを最終的な基礎行列の計算に使用しない)をピクセル単位で示す. 通常は 1~3 の値にセットされる. </param>
3752        /// <param name="param2">RANSAC または LMedSメソッドのときにのみ使用されるパラメータ. F行列の推定精度の信頼レベルを示す.</param>
3753        /// <returns>求めた基礎行列の数(1 または 3).もし行列が求まらないときは0.</returns>
3754        public static int FindFundamentalMat(CvMat points1, CvMat points2, CvMat fundamental_matrix, FundamentalMatMethod method, double param1, double param2)
3755        {
3756            return FindFundamentalMat(points1, points2, fundamental_matrix, method, param1, param2, null);
3757        }
3758        /// <summary>
3759        /// 2枚の画像間の点対応から基礎行列(F行列)を計算する
3760        /// </summary>
3761        /// <param name="points1">大きさが2xN, Nx2, 3xN,または Nx3 の1枚目の画像上の点の配列 (N は点の数).マルチチャンネルで大きさ 1xN,または Nx1 の配 列も使用可能である. 点の座標は浮動小数点型で表される(単精度または倍精度).</param>
3762        /// <param name="points2">2枚目の画像上の点の配列で point1とフォーマットやサイズは同じ.</param>
3763        /// <param name="fundamental_matrix">出力される基礎行列.サイズは 3x3, または 9x3(7-point methodは3つの行列を返す).</param>
3764        /// <param name="method">基礎行列の計算手法</param>
3765        /// <param name="param1">RANSAC メソッドのときにのみ使用されるパラメータ.点からエピポーラ線までの最大距離(その距離を超えるものは外れ値であると判断し,それらを最終的な基礎行列の計算に使用しない)をピクセル単位で示す. 通常は 1~3 の値にセットされる. </param>
3766        /// <param name="param2">RANSAC または LMedSメソッドのときにのみ使用されるパラメータ. F行列の推定精度の信頼レベルを示す.</param>
3767        /// <param name="status">N個の要素からなる出力配列. 各要素は,アウトライア(外れ値)に対しては 0,「インライア」,つまり推定されたエピポーラ幾何に良く適合する値, に対しては 1 にセットされる. この配列は RANSAC または LMedS のときのみ計算される.他の手法では,すべて 1 にセットされる.</param>
3768        /// <returns>求めた基礎行列の数(1 または 3).もし行列が求まらないときは0.</returns>
3769        public static int FindFundamentalMat(CvMat points1, CvMat points2, CvMat fundamental_matrix, FundamentalMatMethod method, double param1, double param2, CvMat status)
3770        {
3771            if (points1 == null)
3772                throw new ArgumentNullException("points1");
3773            if (points2 == null)
3774                throw new ArgumentNullException("points2");
3775            if (fundamental_matrix == null)
3776                throw new ArgumentNullException("fundamental_matrix");
3777            IntPtr statusPtr = (status == null) ? IntPtr.Zero : status.CvPtr;
3778            return CvDll.cvFindFundamentalMat(points1.CvPtr, points2.CvPtr, fundamental_matrix.CvPtr, method, param1, param2, statusPtr);
3779        }
3780        #endregion
3781        #region FindHomography
3782        /// <summary>
3783        /// 2枚の画像間の射影変換を求める
3784        /// </summary>
3785        /// <param name="src_points">1枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).ここで N は点の数.</param>
3786        /// <param name="dst_points">2枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).</param>
3787        /// <param name="homography">出力される3x3ホモグラフィ行列(平面射影変換行列). </param>
3788        public static int FindHomography(CvMat src_points, CvMat dst_points, CvMat homography)
3789        {
3790            return FindHomography(src_points, dst_points, homography, HomographyMethod.Default, 0, null);
3791        }
3792        /// <summary>
3793        /// 2枚の画像間の射影変換を求める
3794        /// </summary>
3795        /// <param name="src_points">1枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).ここで N は点の数.</param>
3796        /// <param name="dst_points">2枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).</param>
3797        /// <param name="homography">出力される3x3ホモグラフィ行列(平面射影変換行列). </param>
3798        /// <param name="method"></param>
3799        public static int FindHomography(CvMat src_points, CvMat dst_points, CvMat homography, HomographyMethod method)
3800        {
3801            return FindHomography(src_points, dst_points, homography, method, 0, null);
3802        }
3803        /// <summary>
3804        /// 2枚の画像間の射影変換を求める
3805        /// </summary>
3806        /// <param name="src_points">1枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).ここで N は点の数.</param>
3807        /// <param name="dst_points">2枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).</param>
3808        /// <param name="homography">出力される3x3ホモグラフィ行列(平面射影変換行列). </param>
3809        /// <param name="method"></param>
3810        /// <param name="ransacReprojThreshold"></param>
3811        public static int FindHomography(CvMat src_points, CvMat dst_points, CvMat homography, HomographyMethod method, double ransacReprojThreshold)
3812        {
3813            return FindHomography(src_points, dst_points, homography, method, ransacReprojThreshold, null);
3814        }
3815        /// <summary>
3816        /// 2枚の画像間の射影変換を求める
3817        /// </summary>
3818        /// <param name="src_points">1枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).ここで N は点の数.</param>
3819        /// <param name="dst_points">2枚目の画像上の座標. 2xN,Nx2,3xN または Nx3の配列 (後ろ二つは同次座標系表記である).</param>
3820        /// <param name="homography">出力される3x3ホモグラフィ行列(平面射影変換行列). </param>
3821        /// <param name="method"></param>
3822        /// <param name="ransacReprojThreshold"></param>
3823        /// <param name="mask"></param>
3824        public static int FindHomography(CvMat src_points, CvMat dst_points, CvMat homography, HomographyMethod method, double ransacReprojThreshold, CvMat mask)
3825        {
3826            if (src_points == null)
3827                throw new ArgumentNullException("src_points");
3828            if (dst_points == null)
3829                throw new ArgumentNullException("dst_points");
3830            if (homography == null)
3831                throw new ArgumentNullException("homography");
3832            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
3833            return CvDll.cvFindHomography(src_points.CvPtr, dst_points.CvPtr, homography.CvPtr, method, ransacReprojThreshold, maskPtr);
3834        }
3835        #endregion
3836        #region FindNearestPoint2D
3837        /// <summary>
3838        /// 与えられた点に最も近い細分割の頂点を求める. 入力点を細分割内に配置するもう一つの関数である.
3839        /// この関数は入力された点に最も近い頂点を求める.
3840        /// </summary>
3841        /// <param name="subdiv">ドロネー,または他の細分割</param>
3842        /// <param name="pt">入力点</param>
3843        /// <returns></returns>
3844        public static CvSubdiv2DPoint FindNearestPoint2D(CvSubdiv2D subdiv, CvPoint2D32f pt)
3845        {
3846            if (subdiv == null)
3847            {
3848                throw new ArgumentNullException("subdiv");
3849            }
3850            IntPtr result = CvDll.cvFindNearestPoint2D(subdiv.CvPtr, pt);
3851            return new CvSubdiv2DPoint(result);
3852        }
3853        #endregion
3854        #region FindNextContour
3855#if LANG_JA
3856        /// <summary>
3857        /// 画像中の次の輪郭を検索する
3858        /// </summary>
3859        /// <param name="scanner">関数cvStartFindContoursで初期化された輪郭スキャナ</param>
3860        /// <returns></returns>
3861#else
3862        /// <summary>
3863        /// Finds next contour in the image
3864        /// </summary>
3865        /// <param name="scanner">Contour scanner initialized by The function cvStartFindContours </param>
3866#endif
3867        public static CvSeq<CvPoint> FindNextContour(this CvContourScanner scanner)
3868        {
3869            if (scanner == null)
3870            {
3871                throw new ArgumentNullException("scanner");
3872            }
3873
3874            // return scanner.FindNextContour();
3875
3876            IntPtr result = CvDll.cvFindNextContour(scanner.CvPtr);
3877            if (result == IntPtr.Zero)
3878                return null;
3879            else
3880                return new CvSeq<CvPoint>(result);
3881        }
3882        #endregion
3883        #region FindStereoCorrespondence
3884        /// <summary>
3885        /// ステレオペア間の視差を計算する
3886        /// </summary>
3887        /// <param name="leftImage">ステレオペアの左画像.8ビット,グレースケールの(傾きや位置などが)修正された画像.</param>
3888        /// <param name="rightImage">ステレオペアの右画像.8ビット,グレースケールの修正された画像.</param>
3889        /// <param name="mode">視差を計算するためのアルゴリズム(現在は,CV_DISPARITY_BIRCHFIELD のみをサポートしている).</param>
3890        /// <param name="depthImage">結果のデプス画像.視差を表すようにスケーリングされた,8ビット,グレースケール画像. つまり,ゼロ視差(これは,カメラから非常に遠い場所の点にあたる)は 0 にマッピングされ,最大視差は 255 にマッピングされる.</param>
3891        /// <param name="maxDisparity">取りうる最大視差.オブジェクトがカメラに近ければ近い程,ここには大きな値が指定されるべきである. ただし,大きすぎる値は,処理速度を極端に低下させる.</param>
3892        /// <param name="param1">アルゴリズムのパラメータ. オクルージョンペナルティ定数 など</param>
3893        /// <param name="param2">アルゴリズムのパラメータ. 一致報酬 など</param>
3894        /// <param name="param3">アルゴリズムのパラメータ. 高信頼度の領域(param3 以上の信頼性を持つ,隣接するピクセルの組)の定義 など</param>
3895        /// <param name="param4">アルゴリズムのパラメータ. 中信頼度の領域の定義 など</param>
3896        /// <param name="param5">アルゴリズムのパラメータ. 低信頼度の領域の定義 など</param>
3897        public static void FindStereoCorrespondence(CvArr leftImage, CvArr rightImage, DisparityMode mode, CvArr depthImage, int maxDisparity, double param1, double param2, double param3, double param4, double param5)
3898        {
3899            if (leftImage == null)
3900                throw new ArgumentNullException("leftImage");
3901            if (rightImage == null)
3902                throw new ArgumentNullException("rightImage");
3903            if (depthImage == null)
3904                throw new ArgumentNullException("depthImage");
3905            CvDll.cvFindStereoCorrespondence(leftImage.CvPtr, rightImage.CvPtr, mode, depthImage.CvPtr, maxDisparity, param1, param2, param3, param4, param5);
3906        }
3907        #endregion
3908        #region FindStereoCorrespondenceBM
3909        /// <summary>
3910        /// ブロックマッチングアルゴリズムを用いて視差画像を計算する (cvFindStereoCorrespondenceBM相当)
3911        /// </summary>
3912        /// <param name="left">左画像.シングルチャンネル,8ビット.</param>
3913        /// <param name="right">右画像.左画像と同じサイズ,同じ種類.</param>
3914        /// <param name="disparity">出力の視差配列.シングルチャンネル,16ビット,符号有り整数,入力画像と同サイズ.各要素は,計算された視差であり,16倍されて整数値にまるめられる.</param>
3915        /// <param name="state">ステレオマッチング構造体.</param>
3916        public static void FindStereoCorrespondenceBM(CvArr left, CvArr right, CvArr disparity, CvStereoBMState state)
3917        {
3918            if (left == null)
3919                throw new ArgumentNullException("left");
3920            if (right == null)
3921                throw new ArgumentNullException("right");
3922            if (disparity == null)
3923                throw new ArgumentNullException("disparity");
3924            if (state == null)
3925                throw new ArgumentNullException("state");
3926            CvDll.cvFindStereoCorrespondenceBM(left.CvPtr, right.CvPtr, disparity.CvPtr, state.CvPtr);
3927        }
3928        #endregion
3929        #region FindStereoCorrespondenceGC
3930        /// <summary>
3931        /// グラフカットに基づくアルゴリズムにより視差画像を計算する (cvFindStereoCorrespondenceGC相当)
3932        /// </summary>
3933        /// <param name="left">左画像.シングルチャンネル,8ビット.</param>
3934        /// <param name="right">右画像.左画像と同じサイズ,同じ種類.</param>
3935        /// <param name="dispLeft">出力オプション:シングルチャンネル,16ビット,符号有り整数.入力画像と同じサイズの左視差画像. </param>
3936        /// <param name="dispRight">出力オプション:シングルチャンネル,16ビット,符号有り整数.入力画像と同じサイズの右視差画像. </param>
3937        /// <param name="state">ステレオマッチング構造体.</param>
3938        public static void FindStereoCorrespondenceGC(CvArr left, CvArr right, CvArr dispLeft, CvArr dispRight, CvStereoGCState state)
3939        {
3940            FindStereoCorrespondenceGC(left, right, dispLeft, dispRight, state, false);
3941        }
3942        /// <summary>
3943        /// グラフカットに基づくアルゴリズムにより視差画像を計算する (cvFindStereoCorrespondenceGC相当)
3944        /// </summary>
3945        /// <param name="left">左画像.シングルチャンネル,8ビット.</param>
3946        /// <param name="right">右画像.左画像と同じサイズ,同じ種類.</param>
3947        /// <param name="dispLeft">出力オプション:シングルチャンネル,16ビット,符号有り整数.入力画像と同じサイズの左視差画像. </param>
3948        /// <param name="dispRight">出力オプション:シングルチャンネル,16ビット,符号有り整数.入力画像と同じサイズの右視差画像. </param>
3949        /// <param name="state">ステレオマッチング構造体.</param>
3950        /// <param name="useDisparityGuess">このパラメータが 0 でない場合, あらかじめ定義された視差画像を用いて計算が開始される.つまり, dispLeft と dispRight が共に,妥当な視差画像である必要がある. そうでない場合は,(すべてのピクセルがオクルージョンとなっている)空の視差画像から開始される.</param>
3951        public static void FindStereoCorrespondenceGC(CvArr left, CvArr right, CvArr dispLeft, CvArr dispRight, CvStereoGCState state, bool useDisparityGuess)
3952        {
3953            if (left == null)
3954                throw new ArgumentNullException("left");
3955            if (right == null)
3956                throw new ArgumentNullException("right");
3957            if (dispLeft == null)
3958                throw new ArgumentNullException("dispLeft");
3959            if (dispRight == null)
3960                throw new ArgumentNullException("dispRight");
3961            if (state == null)
3962                throw new ArgumentNullException("state");
3963            CvDll.cvFindStereoCorrespondenceGC(left.CvPtr, right.CvPtr, dispLeft.CvPtr, dispRight.CvPtr, state.CvPtr, useDisparityGuess);
3964            }
3965            #endregion
3966        #region Flip
3967        /// <summary>
3968        /// 配列を反転させる(行と列のインデックスは0が基準である).
3969        /// </summary>
3970        /// <param name="src">入力配列(出力もここに格納される)</param>
3971        public static void Flip(this CvArr src)
3972        {
3973            Flip(src, null);
3974        }
3975        /// <summary>
3976        /// 配列を反転させる(行と列のインデックスは0が基準である).
3977        /// </summary>
3978        /// <param name="src">入力配列</param>
3979        /// <param name="dst">出力配列.もしnullであれば,反転はインプレースモードで行われる</param>
3980        public static void Flip(this CvArr src, CvArr dst)
3981        {
3982            Flip(src, dst, FlipMode.X);
3983        }
3984        /// <summary>
3985        /// 3種類の異なる方法のうち1つを指定して配列を反転させる(行と列のインデックスは0が基準である).
3986        /// </summary>
3987        /// <param name="src">入力配列</param>
3988        /// <param name="dst">出力配列.もしnullであれば,反転はインプレースモードで行われる</param>
3989        /// <param name="flip_mode">配列の反転方法の指定</param>
3990        public static void Flip(this CvArr src, CvArr dst, FlipMode flip_mode)
3991        {
3992            if (src == null)
3993            {
3994                throw new ArgumentNullException("src");
3995            }
3996            IntPtr dstPtr = (dst == null) ? IntPtr.Zero : dst.CvPtr;
3997            CvDll.cvFlip(src.CvPtr, dstPtr, flip_mode);
3998        }
3999        /// <summary>
4000        /// 配列を反転させる(行と列のインデックスは0が基準である). cvFlipのエイリアス.
4001        /// </summary>
4002        /// <param name="src">入力配列(出力もここに格納される)</param>
4003        public static void Mirror(this CvArr src)
4004        {
4005            Flip(src);
4006        }
4007        /// <summary>
4008        /// 配列を反転させる(行と列のインデックスは0が基準である). cvFlipのエイリアス.
4009        /// </summary>
4010        /// <param name="src">入力配列</param>
4011        /// <param name="dst">出力配列.もしnullであれば,反転はインプレースモードで行われる</param>
4012        public static void Mirror(this CvArr src, CvArr dst)
4013        {
4014            Flip(src, dst);
4015        }
4016        /// <summary>
4017        /// 3種類の異なる方法のうち1つを指定して配列を反転させる(行と列のインデックスは0が基準である). cvFlipのエイリアス.
4018        /// </summary>
4019        /// <param name="src">入力配列</param>
4020        /// <param name="dst">出力配列.もしnullであれば,反転はインプレースモードで行われる</param>
4021        /// <param name="flip_mode">配列の反転方法の指定</param>
4022        public static void Mirror(this CvArr src, CvArr dst, FlipMode flip_mode)
4023        {
4024            Flip(src, dst, flip_mode);
4025        }
4026        #endregion
4027        #region Floor
4028        /// <summary>
4029        /// 引数より大きくない最大の整数値を返す.
4030        /// いくつかのアーキテクチャにおいて,これらの関数はC言語の標準的なキャスト演算よりも非常に高速である.
4031        /// 引数の絶対値が2^31より大きい場合,結果は求まらない.また,特別な値(±Inf, NaN)は扱うことができない.
4032        /// </summary>
4033        /// <param name="value">浮動小数点型の入力値</param>
4034        /// <returns></returns>
4035        public static int Floor(double value)
4036        {
4037            return CvInline.cvFloor(value);
4038        }
4039        #endregion
4040    }
4041}
Note: See TracBrowser for help on using the browser.