root/lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Src/Core/Cv_H-Q.cs @ 32679

Revision 32679, 254.2 kB (checked in by schima, 6 years ago)

Haar classifier

Line 
1/*
2 * (C) 2008-2009 Schima
3 * This code is licenced under the LGPL.
4 */
5
6using System;
7using System.Collections.Generic;
8using System.IO;
9using System.Linq;
10using System.Runtime.InteropServices;
11using System.Text;
12using KwsmLab.OpenCvSharp.Extern;
13
14// ReSharper disable InconsistentNaming
15
16namespace KwsmLab.OpenCvSharp
17{
18    public static partial class Cv
19    {
20        #region HaarDetectObjects
21#if LANG_JP
22        /// <summary>
23        /// 与えられた画像からオブジェクトを含む様な矩形領域を検出し,それらの領域を矩形の列として返す.
24        /// </summary>
25        /// <param name="image">この画像の中からオブジェクトを検出する</param>
26        /// <param name="cascade">Haar 分類器カスケード の内部表現</param>
27        /// <param name="storage">オブジェクト候補の矩形が得られた場合に,その矩形列を保存するメモリストレージ</param>
28        /// <returns>CvAvgCompを要素とするCvSeq</returns>
29#else
30        /// <summary>
31        /// Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
32        /// </summary>
33        /// <param name="image">Image to detect objects in. </param>
34        /// <param name="cascade">Haar classifier cascade in internal representation. </param>
35        /// <param name="storage">Memory storage to store the resultant sequence of the object candidate rectangles. </param>
36        /// <returns></returns>
37#endif
38        public static CvSeq<CvAvgComp> HaarDetectObjects(this CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage)
39        {
40            return HaarDetectObjects(image, cascade, storage, 1.1, 3, HaarDetectionType.Default, new CvSize(0, 0));
41        }
42#if LANG_JP
43        /// <summary>
44        /// 与えられた画像からオブジェクトを含む様な矩形領域を検出し,それらの領域を矩形の列として返す.
45        /// </summary>
46        /// <param name="image">この画像の中からオブジェクトを検出する</param>
47        /// <param name="cascade">Haar 分類器カスケード の内部表現</param>
48        /// <param name="storage">オブジェクト候補の矩形が得られた場合に,その矩形列を保存するメモリストレージ</param>
49        /// <param name="scale_factor">スキャン毎に探索ウィンドウがスケーリングされる際のスケールファクタ. 例えばこの値が 1.1 ならば,ウィンドウが 10% 大きくなる</param>
50        /// <returns>CvAvgCompを要素とするCvSeq</returns>
51#else
52        /// <summary>
53        /// Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
54        /// </summary>
55        /// <param name="image">Image to detect objects in. </param>
56        /// <param name="cascade">Haar classifier cascade in internal representation. </param>
57        /// <param name="storage">Memory storage to store the resultant sequence of the object candidate rectangles. </param>
58        /// <param name="scale_factor">The factor by which the search window is scaled between the subsequent scans, for example, 1.1 means increasing window by 10%. </param>
59        /// <returns></returns>
60#endif
61        public static CvSeq<CvAvgComp> HaarDetectObjects(this CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, double scale_factor)
62        {
63            return HaarDetectObjects(image, cascade, storage, scale_factor, 3, HaarDetectionType.Default, new CvSize(0, 0));
64        }
65#if LANG_JP
66        /// <summary>
67        /// 与えられた画像からオブジェクトを含む様な矩形領域を検出し,それらの領域を矩形の列として返す.
68        /// </summary>
69        /// <param name="image">この画像の中からオブジェクトを検出する</param>
70        /// <param name="cascade">Haar 分類器カスケード の内部表現</param>
71        /// <param name="storage">オブジェクト候補の矩形が得られた場合に,その矩形列を保存するメモリストレージ</param>
72        /// <param name="scale_factor">スキャン毎に探索ウィンドウがスケーリングされる際のスケールファクタ. 例えばこの値が 1.1 ならば,ウィンドウが 10% 大きくなる</param>
73        /// <param name="min_neighbors">(これから 1 を引いた値が)オブジェクトを構成する近傍矩形の最小数となる. min_neighbors-1 よりも少ない矩形しか含まないようなグループは全て棄却される. もし min_neighbors が 0 である場合,この関数はグループを一つも生成せず,候補となる矩形を全て返す.これはユーザがカスタマイズしたグループ化処理を適用したい場合に有用である. </param>
74        /// <returns>CvAvgCompを要素とするCvSeq</returns>
75#else
76        /// <summary>
77        /// Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
78        /// </summary>
79        /// <param name="image">Image to detect objects in. </param>
80        /// <param name="cascade">Haar classifier cascade in internal representation. </param>
81        /// <param name="storage">Memory storage to store the resultant sequence of the object candidate rectangles. </param>
82        /// <param name="scale_factor">The factor by which the search window is scaled between the subsequent scans, for example, 1.1 means increasing window by 10%. </param>
83        /// <param name="min_neighbors">Minimum number (minus 1) of neighbor rectangles that makes up an object. All the groups of a smaller number of rectangles than min_neighbors-1 are rejected. If min_neighbors is 0, the function does not any grouping at all and returns all the detected candidate rectangles, which may be useful if the user wants to apply a customized grouping procedure. </param>
84        /// <returns></returns>
85#endif
86        public static CvSeq<CvAvgComp> HaarDetectObjects(this CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, double scale_factor, int min_neighbors)
87        {
88            return HaarDetectObjects(image, cascade, storage, scale_factor, min_neighbors, HaarDetectionType.Default, new CvSize(0, 0));
89        }
90#if LANG_JP
91        /// <summary>
92        /// 与えられた画像からオブジェクトを含む様な矩形領域を検出し,それらの領域を矩形の列として返す.
93        /// </summary>
94        /// <param name="image">この画像の中からオブジェクトを検出する</param>
95        /// <param name="cascade">Haar 分類器カスケード の内部表現</param>
96        /// <param name="storage">オブジェクト候補の矩形が得られた場合に,その矩形列を保存するメモリストレージ</param>
97        /// <param name="scale_factor">スキャン毎に探索ウィンドウがスケーリングされる際のスケールファクタ. 例えばこの値が 1.1 ならば,ウィンドウが 10% 大きくなる</param>
98        /// <param name="min_neighbors">(これから 1 を引いた値が)オブジェクトを構成する近傍矩形の最小数となる. min_neighbors-1 よりも少ない矩形しか含まないようなグループは全て棄却される. もし min_neighbors が 0 である場合,この関数はグループを一つも生成せず,候補となる矩形を全て返す.これはユーザがカスタマイズしたグループ化処理を適用したい場合に有用である. </param>
99        /// <param name="flags">処理モード</param>
100        /// <returns>CvAvgCompを要素とするCvSeq</returns>
101#else
102        /// <summary>
103        /// Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
104        /// </summary>
105        /// <param name="image">Image to detect objects in. </param>
106        /// <param name="cascade">Haar classifier cascade in internal representation. </param>
107        /// <param name="storage">Memory storage to store the resultant sequence of the object candidate rectangles. </param>
108        /// <param name="scale_factor">The factor by which the search window is scaled between the subsequent scans, for example, 1.1 means increasing window by 10%. </param>
109        /// <param name="min_neighbors">Minimum number (minus 1) of neighbor rectangles that makes up an object. All the groups of a smaller number of rectangles than min_neighbors-1 are rejected. If min_neighbors is 0, the function does not any grouping at all and returns all the detected candidate rectangles, which may be useful if the user wants to apply a customized grouping procedure. </param>
110        /// <param name="flags">Mode of operation. Currently the only flag that may be specified is CV_HAAR_DO_CANNY_PRUNING. If it is set, the function uses Canny edge detector to reject some image regions that contain too few or too much edges and thus can not contain the searched object. The particular threshold values are tuned for face detection and in this case the pruning speeds up the processing. </param>
111        /// <returns></returns>
112#endif
113        public static CvSeq<CvAvgComp> HaarDetectObjects(this CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, double scale_factor, int min_neighbors, HaarDetectionType flags)
114        {
115            return HaarDetectObjects(image, cascade, storage, scale_factor, min_neighbors, flags, new CvSize(0, 0));
116        }
117#if LANG_JP
118        /// <summary>
119        /// 与えられた画像からオブジェクトを含む様な矩形領域を検出し,それらの領域を矩形の列として返す.
120        /// </summary>
121        /// <param name="image">この画像の中からオブジェクトを検出する</param>
122        /// <param name="cascade">Haar 分類器カスケード の内部表現</param>
123        /// <param name="storage">オブジェクト候補の矩形が得られた場合に,その矩形列を保存するメモリストレージ</param>
124        /// <param name="scale_factor">スキャン毎に探索ウィンドウがスケーリングされる際のスケールファクタ. 例えばこの値が 1.1 ならば,ウィンドウが 10% 大きくなる</param>
125        /// <param name="min_neighbors">(これから 1 を引いた値が)オブジェクトを構成する近傍矩形の最小数となる. min_neighbors-1 よりも少ない矩形しか含まないようなグループは全て棄却される. もし min_neighbors が 0 である場合,この関数はグループを一つも生成せず,候補となる矩形を全て返す.これはユーザがカスタマイズしたグループ化処理を適用したい場合に有用である. </param>
126        /// <param name="flags">処理モード</param>
127        /// <param name="min_size">最小ウィンドウサイズ.デフォルトでは分類器の学習に用いられたサンプルのサイズが設定される(顔検出の場合は,~20×20).</param>
128        /// <returns>CvAvgCompを要素とするCvSeq</returns>
129#else
130        /// <summary>
131        /// Finds rectangular regions in the given image that are likely to contain objects the cascade has been trained for and returns those regions as a sequence of rectangles.
132        /// </summary>
133        /// <param name="image">Image to detect objects in. </param>
134        /// <param name="cascade">Haar classifier cascade in internal representation. </param>
135        /// <param name="storage">Memory storage to store the resultant sequence of the object candidate rectangles. </param>
136        /// <param name="scale_factor">The factor by which the search window is scaled between the subsequent scans, for example, 1.1 means increasing window by 10%. </param>
137        /// <param name="min_neighbors">Minimum number (minus 1) of neighbor rectangles that makes up an object. All the groups of a smaller number of rectangles than min_neighbors-1 are rejected. If min_neighbors is 0, the function does not any grouping at all and returns all the detected candidate rectangles, which may be useful if the user wants to apply a customized grouping procedure. </param>
138        /// <param name="flags">Mode of operation. Currently the only flag that may be specified is CV_HAAR_DO_CANNY_PRUNING. If it is set, the function uses Canny edge detector to reject some image regions that contain too few or too much edges and thus can not contain the searched object. The particular threshold values are tuned for face detection and in this case the pruning speeds up the processing. </param>
139        /// <param name="min_size">Minimum window size. By default, it is set to the size of samples the classifier has been trained on (~20×20 for face detection). </param>
140        /// <returns></returns>
141#endif
142        public static CvSeq<CvAvgComp> HaarDetectObjects(this CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, double scale_factor, int min_neighbors, HaarDetectionType flags, CvSize min_size)
143        {
144            if (image == null)
145                throw new ArgumentNullException("image");
146            if (cascade == null)
147                throw new ArgumentNullException("cascade");
148            if (storage == null)
149                throw new ArgumentNullException("storage");
150            IntPtr result = CvDll.cvHaarDetectObjects(image.CvPtr, cascade.CvPtr, storage.CvPtr, scale_factor, min_neighbors, flags, min_size);
151            if (result == IntPtr.Zero)
152                return null;
153            else
154                return new CvSeq<CvAvgComp>(result);
155        }
156        #endregion
157        #region HoughCircles
158        #region circle_storage = CvMemStorage
159#if LANG_JP
160        /// <summary>
161        /// ハフ変換を用いてグレースケール画像中の円を検出する
162        /// </summary>
163        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
164        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
165        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
166        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
167        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
168        /// <returns></returns>
169#else
170        /// <summary>
171        /// Finds circles in grayscale image using Hough transform.
172        /// </summary>
173        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
174        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
175        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
176        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
177        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
178        /// <returns></returns>
179#endif
180        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist)
181        {
182            return HoughCircles(image, circle_storage, method, dp, min_dist, 100, 100, 0, 0);
183        }
184#if LANG_JP
185        /// <summary>
186        /// ハフ変換を用いてグレースケール画像中の円を検出する
187        /// </summary>
188        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
189        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
190        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
191        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
192        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
193        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
194        /// <returns></returns>
195#else
196        /// <summary>
197        /// Finds circles in grayscale image using Hough transform.
198        /// </summary>
199        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
200        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
201        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
202        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
203        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
204        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
205        /// <returns></returns>
206#endif
207        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1)
208        {
209            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, 100, 0, 0);
210        }
211#if LANG_JP
212        /// <summary>
213        /// ハフ変換を用いてグレースケール画像中の円を検出する
214        /// </summary>
215        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
216        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
217        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
218        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
219        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
220        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
221        /// <param name="param2">手法に応じた2番目のパラメータ. CV_HOUGH_GRADIENT の場合は,中心検出計算時の閾値.小さすぎると誤検出が多くなる.これに対応する値が大きい円から順に検出される.</param>
222        /// <returns></returns>
223#else
224        /// <summary>
225        /// Finds circles in grayscale image using Hough transform.
226        /// </summary>
227        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
228        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
229        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
230        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
231        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
232        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
233        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
234        /// <returns></returns>
235#endif
236        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2)
237        {
238            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, 0, 0);
239        }
240#if LANG_JP
241        /// <summary>
242        /// ハフ変換を用いてグレースケール画像中の円を検出する
243        /// </summary>
244        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
245        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
246        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
247        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
248        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
249        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
250        /// <param name="param2">手法に応じた2番目のパラメータ. CV_HOUGH_GRADIENT の場合は,中心検出計算時の閾値.小さすぎると誤検出が多くなる.これに対応する値が大きい円から順に検出される.</param>
251        /// <param name="min_radius">検出すべき円の最小半径.</param>
252        /// <returns></returns>
253#else
254        /// <summary>
255        /// Finds circles in grayscale image using Hough transform.
256        /// </summary>
257        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
258        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
259        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
260        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
261        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
262        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
263        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
264        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
265        /// <returns></returns>
266#endif
267        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius)
268        {
269            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, min_radius, 0);
270        }
271#if LANG_JP
272        /// <summary>
273        /// ハフ変換を用いてグレースケール画像中の円を検出する
274        /// </summary>
275        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
276        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
277        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
278        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
279        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
280        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
281        /// <param name="param2">手法に応じた2番目のパラメータ. CV_HOUGH_GRADIENT の場合は,中心検出計算時の閾値.小さすぎると誤検出が多くなる.これに対応する値が大きい円から順に検出される.</param>
282        /// <param name="min_radius">検出すべき円の最小半径.</param>
283        /// <param name="max_radius">検出すべき円の最大半径 デフォルトの最大半径は max(image_width, image_height) にセットされている.</param>
284        /// <returns></returns>
285#else
286        /// <summary>
287        /// Finds circles in grayscale image using Hough transform.
288        /// </summary>
289        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
290        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
291        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
292        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
293        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
294        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
295        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
296        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
297        /// <param name="max_radius">Maximal radius of the circles to search for. By default the maximal radius is set to max(image_width, image_height). </param>
298        /// <returns></returns>
299#endif
300        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMemStorage circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
301        {
302            if (image == null)
303                throw new ArgumentNullException("image");
304            if (circle_storage == null)
305                throw new ArgumentNullException("circle_storage");
306            IntPtr result = CvDll.cvHoughCircles(image.CvPtr, circle_storage.CvPtr, method, dp, min_dist, param1, param2, min_radius, max_radius);
307            if (result == IntPtr.Zero)
308                return null;
309            else
310                return new CvSeq<CvCircleSegment>(result);
311        }
312        #endregion
313        #region circle_storage = CvMat
314#if LANG_JP
315        /// <summary>
316        /// ハフ変換を用いてグレースケール画像中の円を検出する
317        /// </summary>
318        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
319        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
320        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
321        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
322        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
323        /// <returns></returns>
324#else
325        /// <summary>
326        /// Finds circles in grayscale image using Hough transform.
327        /// </summary>
328        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
329        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
330        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
331        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
332        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
333        /// <returns></returns>
334#endif
335        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist)
336        {
337            return HoughCircles(image, circle_storage, method, dp, min_dist, 100, 100, 0, 0);
338        }
339#if LANG_JP
340        /// <summary>
341        /// ハフ変換を用いてグレースケール画像中の円を検出する
342        /// </summary>
343        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
344        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
345        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
346        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
347        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
348        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
349        /// <returns></returns>
350#else
351        /// <summary>
352        /// Finds circles in grayscale image using Hough transform.
353        /// </summary>
354        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
355        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
356        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
357        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
358        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
359        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
360        /// <returns></returns>
361#endif
362        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1)
363        {
364            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, 100, 0, 0);
365        }
366#if LANG_JP
367        /// <summary>
368        /// ハフ変換を用いてグレースケール画像中の円を検出する
369        /// </summary>
370        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
371        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
372        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
373        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
374        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
375        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
376        /// <param name="param2">手法に応じた2番目のパラメータ. CV_HOUGH_GRADIENT の場合は,中心検出計算時の閾値.小さすぎると誤検出が多くなる.これに対応する値が大きい円から順に検出される.</param>
377        /// <returns></returns>
378#else
379        /// <summary>
380        /// Finds circles in grayscale image using Hough transform.
381        /// </summary>
382        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
383        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
384        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
385        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
386        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
387        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
388        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
389        /// <returns></returns>
390#endif
391        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2)
392        {
393            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, 0, 0);
394        }
395#if LANG_JP
396        /// <summary>
397        /// ハフ変換を用いてグレースケール画像中の円を検出する
398        /// </summary>
399        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
400        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
401        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
402        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
403        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
404        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
405        /// <param name="param2">手法に応じた2番目のパラメータ. CV_HOUGH_GRADIENT の場合は,中心検出計算時の閾値.小さすぎると誤検出が多くなる.これに対応する値が大きい円から順に検出される.</param>
406        /// <param name="min_radius">検出すべき円の最小半径.</param>
407        /// <returns></returns>
408#else
409        /// <summary>
410        /// Finds circles in grayscale image using Hough transform.
411        /// </summary>
412        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
413        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
414        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
415        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
416        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
417        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
418        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
419        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
420        /// <returns></returns>
421#endif
422        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius)
423        {
424            return HoughCircles(image, circle_storage, method, dp, min_dist, param1, param2, min_radius, 0);
425        }
426#if LANG_JP
427        /// <summary>
428        /// ハフ変換を用いてグレースケール画像中の円を検出する
429        /// </summary>
430        /// <param name="image">入力画像 (8ビット,シングルチャンネル,グレースケール).</param>
431        /// <param name="circle_storage">検出された円を保存するメモリストレージ</param>
432        /// <param name="method">現状では,CV_HOUGH_GRADIENT(基本的な2段階のハフ変換)のみ実装されている. </param>
433        /// <param name="dp">円の中心を求める際に用いられる計算時の解像度.例えば,この値が 1 の場合は,計算は入力画像と同じ解像度で行われる.2 の場合は,計算は幅・高さともに1/2の解像度になる,等. </param>
434        /// <param name="min_dist">円検出における中心座標間の最小間隔.この値が非常に小さい場合は,正しく抽出されるべき円の近傍に複数の間違った円が検出されることになる.また,逆に非常に大きい場合は,円検出に失敗する. </param>
435        /// <param name="param1">手法に応じた1番目のパラメータ. CV_HOUGH_GRADIENT の場合は,Cannyのエッジ検出器で用いる二つの閾値の高い方の値 (低い方の値は,この値を1/2したものになる).</param>
436        /// <param name="param2">手法に応じた2番目のパラメータ. CV_HOUGH_GRADIENT の場合は,中心検出計算時の閾値.小さすぎると誤検出が多くなる.これに対応する値が大きい円から順に検出される.</param>
437        /// <param name="min_radius">検出すべき円の最小半径.</param>
438        /// <param name="max_radius">検出すべき円の最大半径 デフォルトの最大半径は max(image_width, image_height) にセットされている.</param>
439        /// <returns></returns>
440#else
441        /// <summary>
442        /// Finds circles in grayscale image using Hough transform.
443        /// </summary>
444        /// <param name="image">The input 8-bit single-channel grayscale image. </param>
445        /// <param name="circle_storage">The storage for the circles detected. It can be a memory storage or single row/single column matrix (CvMat*) of type CV_32FC3, to which the circles' parameters are written. </param>
446        /// <param name="method">Currently, the only implemented method is CV_HOUGH_GRADIENT, which is basically 21HT</param>
447        /// <param name="dp">Resolution of the accumulator used to detect centers of the circles. For example, if it is 1, the accumulator will have the same resolution as the input image, if it is 2 - accumulator will have twice smaller width and height, etc. </param>
448        /// <param name="min_dist">Minimum distance between centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. </param>
449        /// <param name="param1">The first method-specific parameter. In case of CV_HOUGH_GRADIENT it is the higher threshold of the two passed to Canny edge detector (the lower one will be twice smaller). </param>
450        /// <param name="param2">The second method-specific parameter. In case of CV_HOUGH_GRADIENT it is accumulator threshold at the center detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first. </param>
451        /// <param name="min_radius">Minimal radius of the circles to search for. </param>
452        /// <param name="max_radius">Maximal radius of the circles to search for. By default the maximal radius is set to max(image_width, image_height). </param>
453        /// <returns></returns>
454#endif
455        public static CvSeq<CvCircleSegment> HoughCircles(this CvArr image, CvMat circle_storage, HoughCirclesMethod method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
456        {
457            if (image == null)
458                throw new ArgumentNullException("image");
459            if (circle_storage == null)
460                throw new ArgumentNullException("circle_storage");
461            IntPtr result = CvDll.cvHoughCircles(image.CvPtr, circle_storage.CvPtr, method, dp, min_dist, param1, param2, min_radius, max_radius);
462            if (result == IntPtr.Zero)
463                return null;
464            else
465                return new CvSeq<CvCircleSegment>(result);
466        }
467        #endregion
468        #endregion
469        #region HoughLines2
470#if LANG_JP
471        /// <summary>
472        /// ハフ(Hough)変換を用いて2値画像から直線を検出する
473        /// </summary>
474        /// <param name="image">入力画像(8ビット,シングルチャンネル,2値化画像).確率的な手法の場合は,画像は関数内で変換される.</param>
475        /// <param name="line_storage">検出された線を保存するメモリストレージ. 関数によって線分のシーケンスがストレージ内につくられ,その参照が返される</param>
476        /// <param name="method">ハフ変換の種類</param>
477        /// <param name="rho">距離解像度(1ピクセル当たりの単位)</param>
478        /// <param name="theta">角度解像度(ラジアン単位で計測)</param>
479        /// <param name="threshold">閾値パラメータ.対応する投票数がthresholdより大きい場合のみ,抽出された線が返される.</param>
480        /// <returns></returns>
481#else
482        /// <summary>
483        /// Finds lines in binary image using Hough transform.
484        /// </summary>
485        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
486        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
487        /// <param name="method">The Hough transform variant.</param>
488        /// <param name="rho">Distance resolution in pixel-related units. </param>
489        /// <param name="theta">Angle resolution measured in radians. </param>
490        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
491        /// <returns></returns>
492#endif
493        public static CvSeq HoughLines2(this CvArr image, CvMemStorage line_storage, HoughLinesMethod method, double rho, double theta, int threshold)
494        {
495            return HoughLines2(image, line_storage, method, rho, theta, threshold, 0, 0);
496        }
497#if LANG_JP
498        /// <summary>
499        /// ハフ(Hough)変換を用いて2値画像から直線を検出する
500        /// </summary>
501        /// <param name="image">入力画像(8ビット,シングルチャンネル,2値化画像).確率的な手法の場合は,画像は関数内で変換される.</param>
502        /// <param name="line_storage">検出された線を保存するメモリストレージ. 関数によって線分のシーケンスがストレージ内につくられ,その参照が返される</param>
503        /// <param name="method">ハフ変換の種類</param>
504        /// <param name="rho">距離解像度(1ピクセル当たりの単位)</param>
505        /// <param name="theta">角度解像度(ラジアン単位で計測)</param>
506        /// <param name="threshold">閾値パラメータ.対応する投票数がthresholdより大きい場合のみ,抽出された線が返される.</param>
507        /// <param name="param1">各手法に応じた1番目のパラメータ.標準的ハフ変換では,使用しない(0).確率的ハフ変換では,最小の線の長さ.マルチスケールハフ変換では, 距離解像度rhoの除数.(荒い距離解像度では rho であり,詳細な解像度では (rho / param1) となる).</param>
508        /// <param name="param2">各手法に応じた2番目のパラメータ.標準的ハフ変換では,使用しない(0).確率的ハフ変換では,同一線上に存在する線分として扱う(つまり,それらを統合しても問題ない),二つの線分の最大の間隔. マルチスケールハフ変換では,角度解像度 thetaの除数. (荒い角度解像度では theta であり,詳細な解像度では (theta / param2) となる). </param>
509        /// <returns></returns>
510#else
511        /// <summary>
512        /// Finds lines in binary image using Hough transform.
513        /// </summary>
514        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
515        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
516        /// <param name="method">The Hough transform variant.</param>
517        /// <param name="rho">Distance resolution in pixel-related units. </param>
518        /// <param name="theta">Angle resolution measured in radians. </param>
519        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
520        /// <param name="param1">The first method-dependent parameter.</param>
521        /// <param name="param2">The second method-dependent parameter.</param>
522        /// <returns></returns>
523#endif
524        public static CvSeq HoughLines2(this CvArr image, CvMemStorage line_storage, HoughLinesMethod method, double rho, double theta, int threshold, double param1, double param2)
525        {
526            if (image == null)
527                throw new ArgumentNullException("image");
528            if (line_storage == null)
529                throw new ArgumentNullException("line_storage");
530            IntPtr result = CvDll.cvHoughLines2(image.CvPtr, line_storage.CvPtr, method, rho, theta, threshold, param1, param2);
531            return new CvSeq(result);
532        }
533#if LANG_JP
534        /// <summary>
535        /// ハフ(Hough)変換を用いて2値画像から直線を検出する
536        /// </summary>
537        /// <param name="image">入力画像(8ビット,シングルチャンネル,2値化画像).確率的な手法の場合は,画像は関数内で変換される.</param>
538        /// <param name="line_storage">検出された線を保存する1行の行列/1列の行列. 行列のヘッダは,そのcols か rowsが検出された線の数となるように,この関数によって変更される.もし実際の線の数が行列のサイズを超える場合は,線の最大可能数が返される(標準的ハフ変換の場合は 投票数でソートされる).</param>
539        /// <param name="method">ハフ変換の種類</param>
540        /// <param name="rho">距離解像度(1ピクセル当たりの単位)</param>
541        /// <param name="theta">角度解像度(ラジアン単位で計測)</param>
542        /// <param name="threshold">閾値パラメータ.対応する投票数がthresholdより大きい場合のみ,抽出された線が返される.</param>
543        /// <returns></returns>
544#else
545        /// <summary>
546        /// Finds lines in binary image using Hough transform.
547        /// </summary>
548        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
549        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
550        /// <param name="method">The Hough transform variant.</param>
551        /// <param name="rho">Distance resolution in pixel-related units. </param>
552        /// <param name="theta">Angle resolution measured in radians. </param>
553        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
554        /// <returns></returns>
555#endif
556        public static CvSeq HoughLines2(this CvArr image, CvMat line_storage, HoughLinesMethod method, double rho, double theta, int threshold)
557        {
558            return HoughLines2(image, line_storage, method, rho, theta, threshold, 0, 0);
559        }
560#if LANG_JP
561        /// <summary>
562        /// ハフ(Hough)変換を用いて2値画像から直線を検出する
563        /// </summary>
564        /// <param name="image">入力画像(8ビット,シングルチャンネル,2値化画像).確率的な手法の場合は,画像は関数内で変換される.</param>
565        /// <param name="line_storage">検出された線を保存する1行の行列/1列の行列. 行列のヘッダは,そのcols か rowsが検出された線の数となるように,この関数によって変更される.もし実際の線の数が行列のサイズを超える場合は,線の最大可能数が返される(標準的ハフ変換の場合は 投票数でソートされる).</param>
566        /// <param name="method">ハフ変換の種類</param>
567        /// <param name="rho">距離解像度(1ピクセル当たりの単位)</param>
568        /// <param name="theta">角度解像度(ラジアン単位で計測)</param>
569        /// <param name="threshold">閾値パラメータ.対応する投票数がthresholdより大きい場合のみ,抽出された線が返される.</param>
570        /// <param name="param1">各手法に応じた1番目のパラメータ.標準的ハフ変換では,使用しない(0).確率的ハフ変換では,最小の線の長さ.マルチスケールハフ変換では, 距離解像度rhoの除数.(荒い距離解像度では rho であり,詳細な解像度では (rho / param1) となる).</param>
571        /// <param name="param2">各手法に応じた2番目のパラメータ.標準的ハフ変換では,使用しない(0).確率的ハフ変換では,同一線上に存在する線分として扱う(つまり,それらを統合しても問題ない),二つの線分の最大の間隔. マルチスケールハフ変換では,角度解像度 thetaの除数. (荒い角度解像度では theta であり,詳細な解像度では (theta / param2) となる). </param>
572        /// <returns></returns>
573#else
574        /// <summary>
575        /// Finds lines in binary image using Hough transform.
576        /// </summary>
577        /// <param name="image">The input 8-bit single-channel binary image. In case of probabilistic method the image is modified by the function. </param>
578        /// <param name="line_storage">The storage for the lines detected. It can be a memory storage or single row/single column matrix (CvMat*) of a particular type to which the lines' parameters are written. </param>
579        /// <param name="method">The Hough transform variant.</param>
580        /// <param name="rho">Distance resolution in pixel-related units. </param>
581        /// <param name="theta">Angle resolution measured in radians. </param>
582        /// <param name="threshold">Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold. </param>
583        /// <param name="param1">The first method-dependent parameter.</param>
584        /// <param name="param2">The second method-dependent parameter.</param>
585        /// <returns></returns>
586#endif
587        public static CvSeq HoughLines2(this CvArr image, CvMat line_storage, HoughLinesMethod method, double rho, double theta, int threshold, double param1, double param2)
588        {
589            if (image == null)
590                throw new ArgumentNullException("image");
591            if (line_storage == null)
592                throw new ArgumentNullException("line_storage");
593            IntPtr result = CvDll.cvHoughLines2(image.CvPtr, line_storage.CvPtr, method, rho, theta, threshold, param1, param2);
594            return new CvSeq(result);
595        }
596        #endregion
597        #region IncRefData
598        /// <summary>
599        /// 参照カウンタポインタが null ではない場合に, CvMat あるいは CvMatND のデータの参照カウンタをインクリメントし,新たなカウンタ値を返す.
600        /// そうでない場合は 0 を返す.
601        /// </summary>
602        /// <param name="arr">配列ヘッダ</param>
603        /// <returns>新たなカウンタ値</returns>
604        public static int IncRefData(this CvArr arr)
605        {
606            if (arr == null)
607            {
608                throw new ArgumentNullException("arr");
609            }
610            return CvInline.cvIncRefData(arr.CvPtr);
611        }
612        #endregion
613        #region InitFont
614        /// <summary>
615        /// 文字描画関数に渡されるフォント構造体を初期化する
616        /// </summary>
617        /// <param name="font">この関数で初期化されるフォントクラス</param>
618        /// <param name="font_face">フォント名の識別子</param>
619        /// <param name="hscale">幅の比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の幅で表示される. 0.5fにした場合, 文字は元々の半分の幅で表示される.</param>
620        /// <param name="vscale">高さの比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の高さで表示される. 0.5fにした場合, 文字は元々の半分の高さで表示される.</param>
621        public static void InitFont(out CvFont font, FontFace font_face, double hscale, double vscale)
622        {
623            font = new CvFont(font_face, hscale, vscale);
624        }
625        /// <summary>
626        /// 文字描画関数に渡されるフォント構造体を初期化する
627        /// </summary>
628        /// <param name="font">この関数で初期化されるフォントクラス</param>
629        /// <param name="font_face">フォント名の識別子</param>
630        /// <param name="hscale">幅の比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の幅で表示される. 0.5fにした場合, 文字は元々の半分の幅で表示される.</param>
631        /// <param name="vscale">高さの比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の高さで表示される. 0.5fにした場合, 文字は元々の半分の高さで表示される.</param>
632        /// <param name="shear">垂直線からの文字の相対的な角度.ゼロの場合は非イタリックフォントで,例えば,1.0fは≈45°を意味する.</param>
633        public static void InitFont(out CvFont font, FontFace font_face, double hscale, double vscale, double shear)
634        {
635            font = new CvFont(font_face, hscale, vscale, shear);
636        }
637        /// <summary>
638        /// 文字描画関数に渡されるフォント構造体を初期化する
639        /// </summary>
640        /// <param name="font">この関数で初期化されるフォントクラス</param>
641        /// <param name="font_face">フォント名の識別子</param>
642        /// <param name="hscale">幅の比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の幅で表示される. 0.5fにした場合, 文字は元々の半分の幅で表示される.</param>
643        /// <param name="vscale">高さの比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の高さで表示される. 0.5fにした場合, 文字は元々の半分の高さで表示される.</param>
644        /// <param name="shear">垂直線からの文字の相対的な角度.ゼロの場合は非イタリックフォントで,例えば,1.0fは≈45°を意味する.</param>
645        /// <param name="thickness">文字の太さ.</param>
646        public static void InitFont(out CvFont font, FontFace font_face, double hscale, double vscale, double shear, int thickness)
647        {
648            font = new CvFont(font_face, hscale, vscale, shear, thickness);
649        }
650        /// <summary>
651        /// 文字描画関数に渡されるフォント構造体を初期化する
652        /// </summary>
653        /// <param name="font">この関数で初期化されるフォントクラス</param>
654        /// <param name="font_face">フォント名の識別子</param>
655        /// <param name="hscale">幅の比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の幅で表示される. 0.5fにした場合, 文字は元々の半分の幅で表示される.</param>
656        /// <param name="vscale">高さの比率.1.0fにした場合,文字はそれぞれのフォントに依存する元々の高さで表示される. 0.5fにした場合, 文字は元々の半分の高さで表示される.</param>
657        /// <param name="shear">垂直線からの文字の相対的な角度.ゼロの場合は非イタリックフォントで,例えば,1.0fは≈45°を意味する.</param>
658        /// <param name="thickness">文字の太さ.</param>
659        /// <param name="line_type">線の種類.</param>
660        public static void InitFont(out CvFont font, FontFace font_face, double hscale, double vscale, double shear, int thickness, LineType line_type)
661        {
662            font = new CvFont(font_face, hscale, vscale, shear, thickness, line_type);
663        }
664        #endregion
665        #region InitImageHeader
666        /// <summary>
667        /// ユーザから渡された参照が指す, ユーザによって確保された画像のヘッダ構造体を初期化し,その参照を返す
668        /// </summary>
669        /// <param name="image">初期化される画像ヘッダ</param>
670        /// <param name="size">画像の幅と高さ</param>
671        /// <param name="depth">画像のカラーデプス</param>
672        /// <param name="channels">チャンネル数</param>
673        /// <returns>初期化された画像ヘッダ</returns>
674        public static IplImage InitImageHeader(IplImage image, CvSize size, BitDepth depth, int channels)
675        {
676            return InitImageHeader(image, size, depth, channels, 0, 4);
677        }
678        /// <summary>
679        /// ユーザから渡された参照が指す, ユーザによって確保された画像のヘッダ構造体を初期化し,その参照を返す
680        /// </summary>
681        /// <param name="image">初期化される画像ヘッダ</param>
682        /// <param name="size">画像の幅と高さ</param>
683        /// <param name="depth">画像のカラーデプス</param>
684        /// <param name="channels">チャンネル数</param>
685        /// <param name="origin">初期化される画像ヘッダ</param>
686        /// <returns>初期化された画像ヘッダ</returns>
687        public static IplImage InitImageHeader(IplImage image, CvSize size, BitDepth depth, int channels, int origin)
688        {
689            return InitImageHeader(image, size, depth, channels, origin, 4);
690        }
691        /// <summary>
692        /// ユーザから渡された参照が指す, ユーザによって確保された画像のヘッダ構造体を初期化し,その参照を返す
693        /// </summary>
694        /// <param name="image">初期化される画像ヘッダ</param>
695        /// <param name="size">画像の幅と高さ</param>
696        /// <param name="depth">画像のカラーデプス</param>
697        /// <param name="channels">チャンネル数</param>
698        /// <param name="origin">初期化される画像ヘッダ</param>
699        /// <param name="align">画像の行のアライメント,通常は4,あるいは 8 バイト.</param>
700        /// <returns>初期化された画像ヘッダ</returns>
701        public static IplImage InitImageHeader(IplImage image, CvSize size, BitDepth depth, int channels, int origin, int align)
702        {
703            if (image == null)
704            {
705                throw new ArgumentNullException("image");
706            }
707            CvDll.cvInitImageHeader(image.CvPtr, size, depth, channels, origin, align);
708            return image;
709        }
710        #endregion
711        #region InitLineIterator
712#if LANG_JP
713        /// <summary>
714        /// ラインイテレータを初期化する
715        /// </summary>
716        /// <param name="image">対象画像</param>
717        /// <param name="pt1">線分の一つ目の端点</param>
718        /// <param name="pt2">線分のニつ目の端点</param>
719        /// <param name="line_iterator">ラインイテレータ状態構造体へのポインタ</param>
720        /// <returns></returns>
721#else
722        /// <summary>
723        /// Initializes line iterator
724        /// </summary>
725        /// <param name="image">Image to sample the line from.  </param>
726        /// <param name="pt1">First ending point of the line segment. </param>
727        /// <param name="pt2">Second ending point of the line segment. </param>
728        /// <param name="line_iterator">Line iterator state structure to be generated. </param>
729        /// <returns>The function cvInitLineIterator initializes the line iterator and returns the number of pixels between two end points. Both points must be inside the image. After the iterator has been initialized, all the points on the raster line that connects the two ending points may be retrieved by successive calls of NextLinePoint point. The points on the line are calculated one by one using 4-connected or 8-connected Bresenham algorithm.</returns>
730#endif
731        public static int InitLineIterator(CvArr image, CvPoint pt1, CvPoint pt2, out CvLineIterator line_iterator)
732        {
733            return InitLineIterator(image, pt1, pt2, out line_iterator, PixelConnectivity.Connectivity_8);
734        }
735#if LANG_JP
736        /// <summary>
737        /// ラインイテレータを初期化する
738        /// </summary>
739        /// <param name="image">対象画像</param>
740        /// <param name="pt1">線分の一つ目の端点</param>
741        /// <param name="pt2">線分のニつ目の端点</param>
742        /// <param name="line_iterator">ラインイテレータ状態構造体へのポインタ</param>
743        /// <param name="connectivity">走査した線分の接続性.4または8</param>
744        /// <returns></returns>
745#else
746        /// <summary>
747        /// Initializes line iterator
748        /// </summary>
749        /// <param name="image">Image to sample the line from.  </param>
750        /// <param name="pt1">First ending point of the line segment. </param>
751        /// <param name="pt2">Second ending point of the line segment. </param>
752        /// <param name="line_iterator">Line iterator state structure to be generated. </param>
753        /// <param name="connectivity">The scanned line connectivity, 4 or 8. </param>
754        /// <returns>The function cvInitLineIterator initializes the line iterator and returns the number of pixels between two end points. Both points must be inside the image. After the iterator has been initialized, all the points on the raster line that connects the two ending points may be retrieved by successive calls of NextLinePoint point. The points on the line are calculated one by one using 4-connected or 8-connected Bresenham algorithm.</returns>
755#endif
756        public static int InitLineIterator(CvArr image, CvPoint pt1, CvPoint pt2, out CvLineIterator line_iterator, PixelConnectivity connectivity)
757        {
758            return InitLineIterator(image, pt1, pt2, out line_iterator, connectivity, false);
759        }
760#if LANG_JP
761        /// <summary>
762        /// ラインイテレータを初期化する
763        /// </summary>
764        /// <param name="image">対象画像</param>
765        /// <param name="pt1">線分の一つ目の端点</param>
766        /// <param name="pt2">線分のニつ目の端点</param>
767        /// <param name="line_iterator">ラインイテレータ状態構造体へのポインタ</param>
768        /// <param name="connectivity">走査した線分の接続性.4または8</param>
769        /// <param name="left_to_right">pt1とpt2とは無関係に線分をいつも左から右に走査する(true)か, pt1からpt2への決まった方向で走査するか(false)を指定するフラグ. </param>
770        /// <returns></returns>
771#else
772        /// <summary>
773        /// Initializes line iterator
774        /// </summary>
775        /// <param name="image">Image to sample the line from.  </param>
776        /// <param name="pt1">First ending point of the line segment. </param>
777        /// <param name="pt2">Second ending point of the line segment. </param>
778        /// <param name="line_iterator">Line iterator state structure to be generated. </param>
779        /// <param name="connectivity">The scanned line connectivity, 4 or 8. </param>
780        /// <param name="left_to_right">The flag, indicating whether the line should be always scanned from the left-most point to the right-most out of pt1 and pt2 (left_to_right=true), or it is scanned in the specified order, from pt1 to pt2 (left_to_right=false). </param>
781        /// <returns>The function cvInitLineIterator initializes the line iterator and returns the number of pixels between two end points. Both points must be inside the image. After the iterator has been initialized, all the points on the raster line that connects the two ending points may be retrieved by successive calls of NextLinePoint point. The points on the line are calculated one by one using 4-connected or 8-connected Bresenham algorithm.</returns>
782#endif
783        public static int InitLineIterator(CvArr image, CvPoint pt1, CvPoint pt2, out CvLineIterator line_iterator, PixelConnectivity connectivity, bool left_to_right)
784        {
785            if (image == null)
786                throw new ArgumentNullException("image");
787            line_iterator = new CvLineIterator(image, pt1, pt2, connectivity, left_to_right);
788            return line_iterator.Count;
789        }
790        #endregion
791        #region InitMatHeader
792#if LANG_JP
793        /// <summary>
794        /// 既に確保された CvMat を初期化する.
795        /// </summary>
796        /// <param name="mat">初期化する行列のヘッダへの参照</param>
797        /// <param name="rows">画像の幅と高さ</param>
798        /// <param name="cols">画像のカラーデプス</param>
799        /// <param name="type">チャンネル数</param>
800        /// <returns>初期化された行列ヘッダ</returns>
801#else
802        /// <summary>
803        /// Initializes matrix header.
804        /// </summary>
805        /// <param name="mat">Reference to the matrix header to be initialized. </param>
806        /// <param name="rows">Number of rows in the matrix. </param>
807        /// <param name="cols">Number of columns in the matrix. </param>
808        /// <param name="type">Type of the matrix elements. </param>
809        /// <returns></returns>
810#endif
811        public static CvMat InitMatHeader(this CvMat mat, int rows, int cols, MatrixType type)
812        {
813            return InitMatHeader<byte>(mat, rows, cols, type, null, CvConst.CV_AUTOSTEP_);
814        }
815#if LANG_JP
816        /// <summary>
817        /// 既に確保された CvMat を初期化する.
818        /// </summary>
819        /// <typeparam name="T"></typeparam>
820        /// <param name="mat">初期化する行列のヘッダへの参照</param>
821        /// <param name="rows">画像の幅と高さ</param>
822        /// <param name="cols">画像のカラーデプス</param>
823        /// <param name="type">チャンネル数</param>
824        /// <param name="data">行列のヘッダで指定されるデータ配列. 長さがrows*cols*channelsの1次元配列を指定する.</param>
825        /// <returns>初期化された行列ヘッダ</returns>
826#else
827        /// <summary>
828        /// Initializes matrix header.
829        /// </summary>
830        /// <typeparam name="T"></typeparam>
831        /// <param name="mat">Reference to the matrix header to be initialized. </param>
832        /// <param name="rows">Number of rows in the matrix. </param>
833        /// <param name="cols">Number of columns in the matrix. </param>
834        /// <param name="type">Type of the matrix elements. </param>
835        /// <param name="data">Optional data pointer assigned to the matrix header. </param>
836        /// <returns></returns>
837#endif
838        public static CvMat InitMatHeader<T>(this CvMat mat, int rows, int cols, MatrixType type, T[] data) where T : struct
839        {
840            return InitMatHeader(mat, rows, cols, type, data, CvConst.CV_AUTOSTEP_);
841        }
842#if LANG_JP
843        /// <summary>
844        /// 既に確保された CvMat を初期化する.
845        /// </summary>
846        /// <typeparam name="T"></typeparam>
847        /// <param name="mat">初期化する行列のヘッダへの参照</param>
848        /// <param name="rows">画像の幅と高さ</param>
849        /// <param name="cols">画像のカラーデプス</param>
850        /// <param name="type">チャンネル数</param>
851        /// <param name="data">行列のヘッダで指定されるデータ配列. 長さがrows*cols*channelsの1次元配列を指定する.</param>
852        /// <param name="step">割り当てられたデータの行長をバイト単位で表す.デフォルトでは,stepには可能な限り小さい値が用いられる.つまり,行列の連続する行間にギャップが存在しない.</param>
853        /// <returns>初期化された行列ヘッダ</returns>
854#else
855        /// <summary>
856        /// Initializes matrix header.
857        /// </summary>
858        /// <typeparam name="T"></typeparam>
859        /// <param name="mat">Reference to the matrix header to be initialized. </param>
860        /// <param name="rows">Number of rows in the matrix. </param>
861        /// <param name="cols">Number of columns in the matrix. </param>
862        /// <param name="type">Type of the matrix elements. </param>
863        /// <param name="data">Optional data pointer assigned to the matrix header. </param>
864        /// <param name="step">Full row width in bytes of the data assigned. By default, the minimal possible step is used, i.e., no gaps is assumed between subsequent rows of the matrix. </param>
865        /// <returns></returns>
866#endif
867        public static CvMat InitMatHeader<T>(this CvMat mat, int rows, int cols, MatrixType type, T[] data, int step) where T : struct
868        {
869            if (mat == null)
870            {
871                throw new ArgumentNullException("mat");
872            }
873            IntPtr result;
874            if (data == null)
875            {
876                result = CvDll.cvInitMatHeader(mat.CvPtr, rows, cols, type, IntPtr.Zero, step);
877            }
878            else
879            {
880                using (ArrayAddress1<T> dataPtr = new ArrayAddress1<T>(data))
881                {
882                    result = CvDll.cvInitMatHeader(mat.CvPtr, rows, cols, type, dataPtr, step);
883                }
884            }
885            if (result == IntPtr.Zero)
886                return null;
887            else
888                return new CvMat(result);
889        }
890        #endregion
891        #region InitMatNDHeader
892#if LANG_JP
893        /// <summary>
894        /// 多次元配列のヘッダを初期化する
895        /// </summary>
896        /// <param name="mat">初期化する配列のヘッダ</param>
897        /// <param name="dims">配列の次元数</param>
898        /// <param name="sizes">次元サイズの配列</param>
899        /// <param name="type">配列要素の種類</param>
900        /// <returns></returns>
901#else
902        /// <summary>
903        /// Initializes multi-dimensional array header.
904        /// </summary>
905        /// <param name="mat">Reference to the array header to be initialized. </param>
906        /// <param name="dims">Number of array dimensions. </param>
907        /// <param name="sizes">Array of dimension sizes. </param>
908        /// <param name="type">Type of array elements. The same as for CvMat. </param>
909        /// <returns></returns>
910#endif
911        public static CvMatND InitMatNDHeader(this CvMatND mat, int dims, int[] sizes, MatrixType type)
912        {
913            return InitMatNDHeader<byte>(mat, dims, sizes, type, null);
914        }
915#if LANG_JP
916        /// <summary>
917        /// 多次元配列のヘッダを初期化する
918        /// </summary>
919        /// <typeparam name="T"></typeparam>
920        /// <param name="mat">初期化する配列のヘッダ</param>
921        /// <param name="dims">配列の次元数</param>
922        /// <param name="sizes">次元サイズの配列</param>
923        /// <param name="type">配列要素の種類</param>
924        /// <param name="data">行列のヘッダで指定されるデータ</param>
925        /// <returns></returns>
926#else
927        /// <summary>
928        /// Initializes multi-dimensional array header.
929        /// </summary>
930        /// <typeparam name="T"></typeparam>
931        /// <param name="mat">Reference to the array header to be initialized. </param>
932        /// <param name="dims">Number of array dimensions. </param>
933        /// <param name="sizes">Array of dimension sizes. </param>
934        /// <param name="type">Type of array elements. The same as for CvMat. </param>
935        /// <param name="data">Optional data pointer assigned to the matrix header. </param>
936        /// <returns></returns>
937#endif
938        public static CvMatND InitMatNDHeader<T>(this CvMatND mat, int dims, int[] sizes, MatrixType type, T[] data) where T : struct
939        {
940            if (mat == null)
941            {
942                throw new ArgumentNullException("mat");
943            }
944            IntPtr result;
945            if (data == null)
946            {
947                result = CvDll.cvInitMatNDHeader(mat.CvPtr, dims, sizes, type, IntPtr.Zero);
948            }
949            else
950            {
951                using (ArrayAddress1<T> dataPtr = new ArrayAddress1<T>(data))
952                {
953                    result = CvDll.cvInitMatNDHeader(mat.CvPtr, dims, sizes, type, dataPtr);
954                }
955            }
956            if (result == IntPtr.Zero)
957                return null;
958            else
959                return new CvMatND(result);
960        }
961        #endregion
962        #region InitSubdivDelaunay2D
963        /// <summary>
964        /// CvSubdiv2Dの初期化
965        /// </summary>
966        /// <param name="subdiv"></param>
967        /// <param name="rect"></param>
968        public static void InitSubdivDelaunay2D(this CvSubdiv2D subdiv, CvRect rect)
969        {
970            if (subdiv == null)
971            {
972                throw new ArgumentNullException("subdiv");
973            }
974            CvDll.cvInitSubdivDelaunay2D(subdiv.CvPtr, rect);
975        }
976        #endregion
977        #region InitTreeNodeIterator
978#if LANG_JP
979        /// <summary>
980        /// ツリーノードのイテレータを初期化する
981        /// </summary>
982        /// <param name="tree_iterator">初期化されるツリーのイテレータ</param>
983        /// <param name="first">先頭ノード.ここから走査を開始する.</param>
984        /// <param name="max_level">ツリー走査範囲の最大レベル(first ノードが第1レベルであると仮定する).
985        /// 例えば,1 はfirstと同じレベルのノードのみが処理されることを意味する, また,2はfirstと同じレベルのノードとその子ノードが処理される.</param>
986#else
987        /// <summary>
988        ///
989        /// </summary>
990        /// <param name="tree_iterator"></param>
991        /// <param name="first"></param>
992        /// <param name="max_level"></param>
993#endif
994        public static void InitTreeNodeIterator(out CvTreeNodeIterator tree_iterator, IntPtr first, int max_level)
995        {
996            if (first == IntPtr.Zero)
997            {
998                throw new ArgumentNullException("first");
999            }
1000            tree_iterator = new CvTreeNodeIterator();
1001            CvDll.cvInitTreeNodeIterator(tree_iterator, first, max_level);
1002        }
1003        #endregion
1004        #region InitUndistortMap
1005        /// <summary>
1006        /// 事前に歪み補正マップ(補正画像のすべてのピクセルについて,それぞれ対応する歪み画像のピクセル座標値をもつマップ)を計算する.
1007        /// その後,マップは入力画像および出力画像と共に,関数 cvRemap に渡すことができる.
1008        /// </summary>
1009        /// <param name="intrinsic_matrix">カメラ内部行列 (A) [fx 0 cx; 0 fy cy; 0 0 1]. </param>
1010        /// <param name="distortion_coeffs">歪み係数ベクトル.4x1 または 1x4 [k1, k2, p1, p2]. </param>
1011        /// <param name="mapx">補正マップのx座標の出力配列</param>
1012        /// <param name="mapy">補正マップのy座標の出力配列</param>
1013        public static void InitUndistortMap(CvMat intrinsic_matrix, CvMat distortion_coeffs, CvArr mapx, CvArr mapy)
1014        {
1015            if (intrinsic_matrix == null)
1016                throw new ArgumentNullException("intrinsic_matrix");
1017            if (distortion_coeffs == null)
1018                throw new ArgumentNullException("distortion_coeffs");
1019            if (mapx == null)
1020                throw new ArgumentNullException("mapx");
1021            if (mapy == null)
1022                throw new ArgumentNullException("mapy");
1023            CvDll.cvInitUndistortMap(intrinsic_matrix.CvPtr, distortion_coeffs.CvPtr, mapx.CvPtr, mapy.CvPtr);
1024        }
1025        #endregion
1026        #region Inpaint
1027#if LANG_JP
1028        /// <summary>
1029        /// 配列の要素値が他の二つの配列要素で表される範囲内に位置するかをチェックする
1030        /// </summary>
1031        /// <param name="src">入力画像(8ビット,1チャンネルあるいは3チャンネル).</param>
1032        /// <param name="mask">修復マスク.8ビット,1チャンネル画像. 非0のピクセルが,修復の必要がある領域であることを示す.</param>
1033        /// <param name="dst">出力画像(入力画像と同じサイズ,同じタイプ).</param>
1034        /// <param name="inpaintRange">修復されるピクセルの円状の隣接領域を示す半径</param>
1035        /// <param name="flags">修復方法</param>   
1036#else
1037        /// <summary>
1038        /// Inpaints the selected region in the image.
1039        /// </summary>
1040        /// <param name="src">The input 8-bit 1-channel or 3-channel image. </param>
1041        /// <param name="mask">The inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that needs to be inpainted. </param>
1042        /// <param name="dst">The output image of the same format and the same size as input. </param>
1043        /// <param name="inpaintRange">The radius of circlular neighborhood of each point inpainted that is considered by the algorithm. </param>
1044        /// <param name="flags">The inpainting method.</param>
1045#endif
1046        public static void Inpaint(this CvArr src, CvArr mask, CvArr dst, double inpaintRange, InpaintMethod flags)
1047        {
1048            if (src == null)
1049                throw new ArgumentNullException("src");
1050            if (mask == null)
1051                throw new ArgumentNullException("mask");
1052            if (dst == null)
1053                throw new ArgumentNullException("dst");
1054            CvDll.cvInpaint(src.CvPtr, mask.CvPtr, dst.CvPtr, inpaintRange, flags);
1055        }
1056        #endregion
1057        #region InRange
1058        /// <summary>
1059        /// 配列の要素値が他の二つの配列要素で表される範囲内に位置するかをチェックする
1060        /// </summary>
1061        /// <param name="src">入力配列</param>
1062        /// <param name="lower">下限値(その値を含む)を表す配列</param>
1063        /// <param name="upper">上限値(その値は含まない)を表す配列</param>
1064        /// <param name="dst">出力配列(タイプは8u または 8s)</param>
1065        public static void InRange(this CvArr src, CvArr lower, CvArr upper, CvArr dst)
1066        {
1067            if (src == null)
1068                throw new ArgumentNullException("src");
1069            if (lower == null)
1070                throw new ArgumentNullException("lower");
1071            if (upper == null)
1072                throw new ArgumentNullException("upper");
1073            if (dst == null)
1074                throw new ArgumentNullException("dst");
1075            CvDll.cvInRange(src.CvPtr, lower.CvPtr, upper.CvPtr, dst.CvPtr);
1076        }
1077        #endregion
1078        #region InRangeS
1079        /// <summary>
1080        /// 配列の要素値が二つのスカラーの間に位置するかをチェックする
1081        /// </summary>
1082        /// <param name="src">入力配列</param>
1083        /// <param name="lower">下限値(その値を含む)</param>
1084        /// <param name="upper">上限値(その値は含まない)</param>
1085        /// <param name="dst">出力配列(タイプは8u または 8s)</param>
1086        public static void InRangeS(this CvArr src, CvScalar lower, CvScalar upper, CvArr dst)
1087        {
1088            if (src == null)
1089                throw new ArgumentNullException("src");
1090            if (dst == null)
1091                throw new ArgumentNullException("dst");
1092            CvDll.cvInRangeS(src.CvPtr, lower, upper, dst.CvPtr);
1093        }
1094        #endregion
1095        #region Integral
1096#if LANG_JP
1097        /// <summary>
1098        /// 任意の矩形領域の画素値の総和を計算する
1099        /// </summary>
1100        /// <param name="image">入力画像,W×H,8ビットあるいは浮動小数点(32fか64f)画像.</param>
1101        /// <param name="sum">インテグラルイメージ(integral image),W+1×H+1,32ビット整数型あるいは倍精度浮動小数点型(64f). </param>
1102#else
1103        /// <summary>
1104        /// Calculates integral images.
1105        /// </summary>
1106        /// <param name="image">The source image, WxH, 8-bit or floating-point (32f or 64f) image. </param>
1107        /// <param name="sum">The integral image, W+1xH+1, 32-bit integer or double precision floating-point (64f). </param>
1108#endif
1109        public static void Integral(CvArr image, CvArr sum)
1110        {
1111            Integral(image, sum, null, null);
1112        }
1113#if LANG_JP
1114        /// <summary>
1115        /// 任意の矩形領域の画素値の総和を計算する
1116        /// </summary>
1117        /// <param name="image">入力画像,W×H,8ビットあるいは浮動小数点(32fか64f)画像.</param>
1118        /// <param name="sum">インテグラルイメージ(integral image),W+1×H+1,32ビット整数型あるいは倍精度浮動小数点型(64f). </param>
1119        /// <param name="sqsum">オプション:各ピクセル値を2乗したインテグラルイメージ,W+1×H+1,倍精度浮動小数点型(64f). </param>
1120#else
1121        /// <summary>
1122        /// Calculates integral images.
1123        /// </summary>
1124        /// <param name="image">The source image, WxH, 8-bit or floating-point (32f or 64f) image. </param>
1125        /// <param name="sum">The integral image, W+1xH+1, 32-bit integer or double precision floating-point (64f). </param>
1126        /// <param name="sqsum">The integral image for squared pixel values, W+1xH+1, double precision floating-point (64f). </param>
1127#endif
1128        public static void Integral(CvArr image, CvArr sum, CvArr sqsum)
1129        {
1130            Integral(image, sum, sqsum, null);
1131        }
1132#if LANG_JP
1133        /// <summary>
1134        /// 任意の矩形領域の画素値の総和を計算する
1135        /// </summary>
1136        /// <param name="image">入力画像,W×H,8ビットあるいは浮動小数点(32fか64f)画像.</param>
1137        /// <param name="sum">インテグラルイメージ(integral image),W+1×H+1,32ビット整数型あるいは倍精度浮動小数点型(64f). </param>
1138        /// <param name="sqsum">オプション:各ピクセル値を2乗したインテグラルイメージ,W+1×H+1,倍精度浮動小数点型(64f). </param>
1139        /// <param name="tilted_sum">オプション:45度回転させた入力画像のインテグラルイメージ,W+1×H+1,sumと同じデータフォーマット.</param>
1140#else
1141        /// <summary>
1142        /// Calculates integral images.
1143        /// </summary>
1144        /// <param name="image">The source image, WxH, 8-bit or floating-point (32f or 64f) image. </param>
1145        /// <param name="sum">The integral image, W+1xH+1, 32-bit integer or double precision floating-point (64f). </param>
1146        /// <param name="sqsum">The integral image for squared pixel values, W+1xH+1, double precision floating-point (64f). </param>
1147        /// <param name="tilted_sum">The integral for the image rotated by 45 degrees, W+1xH+1, the same data type as sum. </param>
1148#endif
1149        public static void Integral(CvArr image, CvArr sum, CvArr sqsum, CvArr tilted_sum)
1150        {
1151            if (image == null)
1152                throw new ArgumentNullException("image");
1153            if (sum == null)
1154                throw new ArgumentNullException("sum");
1155            IntPtr sqsum_ptr = (sqsum == null) ? IntPtr.Zero : sqsum.CvPtr;
1156            IntPtr tilted_sum_ptr = (tilted_sum == null) ? IntPtr.Zero : tilted_sum.CvPtr;
1157            CvDll.cvIntegral(image.CvPtr, sum.CvPtr, sqsum_ptr, tilted_sum_ptr);
1158        }
1159        #endregion
1160        #region Invert
1161        /// <summary>
1162        /// 逆行列または擬似逆行列を求める. Invertのエイリアス.
1163        /// </summary>
1164        /// <param name="src">入力行列</param>
1165        /// <param name="dst">出力行列</param>
1166        /// <returns></returns>
1167        public static double Inv(this CvArr src, CvArr dst)
1168        {
1169            return Invert(src, dst);
1170        }
1171        /// <summary>
1172        /// 逆行列または擬似逆行列を求める. Invertのエイリアス.
1173        /// </summary>
1174        /// <param name="src">入力行列</param>
1175        /// <param name="dst">出力行列</param>
1176        /// <param name="method">逆行列を求める手法</param>
1177        /// <returns></returns>
1178        public static double Inv(this CvArr src, CvArr dst, InvertMethod method)
1179        {
1180            return Invert(src, dst, method);
1181        }
1182        /// <summary>
1183        /// 逆行列または擬似逆行列を求める.
1184        /// </summary>
1185        /// <param name="src">入力行列</param>
1186        /// <param name="dst">出力行列</param>
1187        /// <returns></returns>
1188        public static double Invert(this CvArr src, CvArr dst)
1189        {
1190            return Invert(src, dst, InvertMethod.LU);
1191        }
1192        /// <summary>
1193        /// 逆行列または擬似逆行列を求める.
1194        /// </summary>
1195        /// <param name="src">入力行列</param>
1196        /// <param name="dst">出力行列</param>
1197        /// <param name="method">逆行列を求める手法</param>
1198        /// <returns></returns>
1199        public static double Invert(this CvArr src, CvArr dst, InvertMethod method)
1200        {
1201            if (src == null)
1202                throw new ArgumentNullException("src");
1203            if (dst == null)
1204                throw new ArgumentNullException("dst");
1205            return CvDll.cvInvert(src.CvPtr, dst.CvPtr, method);
1206        }
1207        #endregion
1208        #region InvSqrt
1209#if LANG_JP
1210        /// <summary>
1211        /// 引数の平方根の逆数を計算する.
1212        /// これは,通常,1./sqrt(value)を計算するよりも高速である.
1213        /// 引数が0または負の値のとき,結果は求まらない.また,特別な値(±Inf, NaN)は扱うことができない.
1214        /// </summary>
1215        /// <param name="value">浮動小数点型の入力値</param>
1216        /// <returns></returns>
1217#else
1218        /// <summary>
1219        /// Calculates inverse square root
1220        /// </summary>
1221        /// <param name="value">The input floating-point value </param>
1222        /// <returns></returns>
1223#endif
1224        public static float InvSqrt(float value)
1225        {
1226            return CvDll.cvInvSqrt(value);
1227        }
1228        #endregion
1229        #region IsGraphEdgeVisited
1230#if LANG_JP
1231        /// <summary>
1232        ///
1233        /// </summary>
1234        /// <param name="edge">グラフ頂点への参照</param>
1235        /// <returns></returns>
1236#else
1237        /// <summary>
1238        ///
1239        /// </summary>
1240        /// <param name="edge">Graph vertex. </param>
1241        /// <returns></returns>
1242#endif
1243        public static int IsGraphEdgeVisited(this  CvGraphEdge edge)
1244        {
1245            if (edge == null)
1246            {
1247                throw new ArgumentNullException("edge");
1248            }
1249            return CvInline.CV_IS_GRAPH_EDGE_VISITED_(edge.CvPtr);
1250        }
1251        #endregion
1252        #region IsGraphVertexVisited
1253#if LANG_JP
1254        /// <summary>
1255        ///
1256        /// </summary>
1257        /// <param name="vtx">グラフ頂点への参照</param>
1258        /// <returns></returns>
1259#else
1260        /// <summary>
1261        ///
1262        /// </summary>
1263        /// <param name="vtx">Graph vertex. </param>
1264        /// <returns></returns>
1265#endif
1266        public static int IsGraphVertexVisited(this  CvGraphVtx vtx)
1267        {
1268            if (vtx == null)
1269            {
1270                throw new ArgumentNullException("vtx");
1271            }
1272            return CvInline.CV_IS_GRAPH_VERTEX_VISITED_(vtx.CvPtr);
1273        }
1274        #endregion
1275        #region IsInf
1276        /// <summary>
1277        /// 引数が±無限大(IEEE754 standard に定義されている)であればtrueを返し,その他の場合はfalseを返す.
1278        /// </summary>
1279        /// <param name="value">浮動小数点型の入力値</param>
1280        /// <returns></returns>
1281        public static bool IsInf(double value)
1282        {
1283            return CvInline.cvIsInf(value) != 0;
1284        }
1285        #endregion
1286        #region IsNaN
1287        /// <summary>
1288        /// 引数が数値(IEEE754 standard に定義されている)でなければtrueを返し,その他の場合はfalseを返す.
1289        /// </summary>
1290        /// <param name="value">浮動小数点型の入力値</param>
1291        /// <returns></returns>
1292        public static bool IsNaN(double value)
1293        {
1294            return CvInline.cvIsNaN(value) != 0;
1295        }
1296        #endregion
1297        #region KalmanCorrect
1298#if LANG_JP
1299        /// <summary>
1300        /// モデル状態を修正する. 修正された状態を kalman->state_post に保存し,これを出力として返す.
1301        /// </summary>
1302        /// <param name="kalman">更新されるカルマンフィルタ状態</param>
1303        /// <param name="measurement">観測ベクトルを含むCvMat</param>
1304        /// <returns>修正された状態を kalman->state_post に保存し,これを出力として返す.</returns>
1305#else
1306        /// <summary>
1307        /// Adjusts model state
1308        /// </summary>
1309        /// <param name="kalman">Kalman filter</param>
1310        /// <param name="measurement">CvMat containing the measurement vector. </param>
1311        /// <returns>The function stores adjusted state at kalman->state_post and returns it on output.</returns>
1312#endif
1313        public static CvMat KalmanCorrect(CvKalman kalman, CvMat measurement)
1314        {
1315            if (kalman == null)
1316                throw new ArgumentNullException("kalman");
1317            if (measurement == null)
1318                throw new ArgumentNullException("measurement");
1319            IntPtr result = CvDll.cvKalmanPredict(kalman.CvPtr, measurement.CvPtr);
1320            return new CvMat(result, false);
1321        }
1322#if LANG_JP
1323        /// <summary>
1324        /// モデル状態を修正する. 修正された状態を kalman->state_post に保存し,これを出力として返す.cvKalmanCorrectのエイリアス.
1325        /// </summary>
1326        /// <param name="kalman">更新されるカルマンフィルタ状態</param>
1327        /// <param name="measurement">観測ベクトルを含むCvMat</param>
1328        /// <returns>修正された状態を kalman->state_post に保存し,これを出力として返す.</returns>
1329#else
1330        /// <summary>
1331        /// Adjusts model state
1332        /// </summary>
1333        /// <param name="kalman">Kalman filter</param>
1334        /// <param name="measurement">CvMat containing the measurement vector. </param>
1335        /// <returns>The function stores adjusted state at kalman->state_post and returns it on output.</returns>
1336#endif
1337        public static CvMat KalmanUpdateByMeasurement(CvKalman kalman, CvMat measurement)
1338        {
1339            return KalmanCorrect(kalman, measurement);
1340        }
1341        #endregion
1342        #region KalmanPredict
1343#if LANG_JP
1344        /// <summary>
1345        /// 次のモデル状態を推定する.
1346        /// </summary>
1347        /// <param name="kalman">カルマンフィルタ状態</param>
1348        /// <returns></returns>
1349#else
1350        /// <summary>
1351        /// Estimates subsequent model state
1352        /// </summary>
1353        /// <param name="kalman">Kalman filter state. </param>
1354        /// <returns>The function returns the estimated state. </returns>
1355#endif
1356        public static CvMat KalmanPredict(CvKalman kalman)
1357        {
1358            return KalmanPredict(kalman, null);
1359        }
1360#if LANG_JP
1361        /// <summary>
1362        /// 次のモデル状態を推定する
1363        /// </summary>
1364        /// <param name="kalman">カルマンフィルタ状態</param>
1365        /// <param name="control">コントロールベクトル (uk).外部コントロールが存在しない場合(control_params=0)に限り,null である.</param>
1366        /// <returns></returns>
1367#else
1368        /// <summary>
1369        /// Estimates subsequent model state
1370        /// </summary>
1371        /// <param name="kalman">Kalman filter state. </param>
1372        /// <param name="control">Control vector (uk), should be null iff there is no external control (control_params=0).</param>
1373        /// <returns>The function returns the estimated state. </returns>
1374#endif
1375        public static CvMat KalmanPredict(CvKalman kalman, CvMat control)
1376        {
1377            if (kalman == null)
1378                throw new ArgumentNullException("kalman");
1379            IntPtr controlPtr = (control == null) ? IntPtr.Zero : control.CvPtr;
1380            IntPtr result = CvDll.cvKalmanPredict(kalman.CvPtr, controlPtr);
1381            if (result == IntPtr.Zero)
1382                return null;
1383            else
1384                return new CvMat(result, false);
1385        }
1386#if LANG_JP
1387        /// <summary>
1388        /// 次のモデル状態を推定する. cvKalmanPredictのエイリアス.
1389        /// </summary>
1390        /// <param name="kalman">カルマンフィルタ状態</param>
1391        /// <returns></returns>
1392#else
1393        /// <summary>
1394        /// Estimates subsequent model state
1395        /// </summary>
1396        /// <param name="kalman">Kalman filter state. </param>
1397        /// <returns>The function returns the estimated state. </returns>
1398#endif
1399        public static CvMat KalmanUpdateByTime(CvKalman kalman)
1400        {
1401            return KalmanPredict(kalman);
1402        }
1403#if LANG_JP
1404        /// <summary>
1405        /// 次のモデル状態を推定する. cvKalmanPredictのエイリアス.
1406        /// </summary>
1407        /// <param name="kalman">カルマンフィルタ状態</param>
1408        /// <param name="control">コントロールベクトル (uk).外部コントロールが存在しない場合(control_params=0)に限り,null である.</param>
1409        /// <returns></returns>
1410#else
1411        /// <summary>
1412        /// Estimates subsequent model state
1413        /// </summary>
1414        /// <param name="kalman">Kalman filter state. </param>
1415        /// <param name="control">Control vector (uk), should be null iff there is no external control (control_params=0).</param>
1416        /// <returns>The function returns the estimated state. </returns>
1417#endif
1418        public static CvMat KalmanUpdateByTime(CvKalman kalman, CvMat control)
1419        {
1420            return KalmanPredict(kalman, control);
1421        }
1422        #endregion
1423        #region KMeans
1424        /// <summary>
1425        /// ベクトル集合を,与えられたクラスタ数に分割する.
1426        /// 入力サンプルを各クラスタに分類するために cluster_count 個のクラスタの中心を求める k-means 法を実装する.
1427        /// 出力 labels(i) は,配列 samples のi番目の行のサンプルが属するクラスタのインデックスを表す.
1428        /// </summary>
1429        /// <param name="samples">浮動小数点型の入力サンプル行列.1行あたり一つのサンプル.</param>
1430        /// <param name="cluster_count">集合を分割するクラスタ数</param>
1431        /// <param name="labels">出力の整数ベクトル.すべてのサンプルについて,それぞれがどのクラスタに属しているかが保存されている.</param>
1432        /// <param name="termcrit">最大繰り返し数と(または),精度(1ループでの各クラスタ中心位置移動距離)の指定</param>
1433        public static void KMeans2(this CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit)
1434        {
1435            if (samples == null)
1436                throw new ArgumentNullException("samples");
1437            if (labels == null)
1438                throw new ArgumentNullException("labels");
1439            CvDll.cvKMeans2(samples.CvPtr, cluster_count, labels.CvPtr, termcrit);
1440        }
1441        #endregion
1442        #region Laplace
1443#if LANG_JP
1444        /// <summary>
1445        /// Sobel演算子を用いて計算されたxとyの2次微分を加算することで,入力画像のラプラシアン(Laplacian)を計算する [aperture_size=3]
1446        /// </summary>
1447        /// <param name="src">入力画像</param>
1448        /// <param name="dst">出力画像</param>
1449#else
1450        /// <summary>
1451        /// Calculates Laplacian of the source image by summing second x- and y- derivatives calculated using Sobel operator.
1452        /// </summary>
1453        /// <param name="src">Source image. </param>
1454        /// <param name="dst">Destination image. </param>
1455#endif
1456        public static void Laplace(this CvArr src, CvArr dst)
1457        {
1458            Laplace(src, dst, ApertureSize.Size3);
1459        }
1460#if LANG_JP
1461        /// <summary>
1462        /// Sobel演算子を用いて計算されたxとyの2次微分を加算することで,入力画像のラプラシアン(Laplacian)を計算する
1463        /// </summary>
1464        /// <param name="src">入力画像</param>
1465        /// <param name="dst">出力画像</param>
1466        /// <param name="aperture_size">拡張Sobelカーネルのサイズ</param>
1467#else
1468        /// <summary>
1469        /// Calculates Laplacian of the source image by summing second x- and y- derivatives calculated using Sobel operator.
1470        /// </summary>
1471        /// <param name="src">Source image. </param>
1472        /// <param name="dst">Destination image. </param>
1473        /// <param name="aperture_size">Aperture size (it has the same meaning as in cvSobel). </param>
1474#endif
1475        public static void Laplace(this CvArr src, CvArr dst, ApertureSize aperture_size)
1476        {
1477            if (src == null)
1478                throw new ArgumentNullException("src");
1479            if (dst == null)
1480                throw new ArgumentNullException("dst");
1481            CvDll.cvLaplace(src.CvPtr, dst.CvPtr, aperture_size);
1482        }
1483        #endregion
1484        #region Line
1485        /// <summary>
1486        /// 2点を結ぶ線分を画像上に描画する.
1487        /// </summary>
1488        /// <param name="img">画像</param>
1489        /// <param name="pt1x">線分の1番目の端点x</param>
1490        /// <param name="pt1y">線分の1番目の端点y</param>
1491        /// <param name="pt2x">線分の2番目の端点x</param>
1492        /// <param name="pt2y">線分の2番目の端点y</param>
1493        /// <param name="color">線分の色</param>
1494        public static void Line(this CvArr img, int pt1x, int pt1y, int pt2x, int pt2y, CvScalar color)
1495        {
1496            Line(img, new CvPoint(pt1x, pt1y), new CvPoint(pt2x, pt2y), color);
1497        }
1498        /// <summary>
1499        /// 2点を結ぶ線分を画像上に描画する.
1500        /// </summary>
1501        /// <param name="img">画像</param>
1502        /// <param name="pt1x">線分の1番目の端点x</param>
1503        /// <param name="pt1y">線分の1番目の端点y</param>
1504        /// <param name="pt2x">線分の2番目の端点x</param>
1505        /// <param name="pt2y">線分の2番目の端点y</param>
1506        /// <param name="color">線分の色</param>
1507        /// <param name="thickness">線分の太さ</param>
1508        public static void Line(this CvArr img, int pt1x, int pt1y, int pt2x, int pt2y, CvScalar color, int thickness)
1509        {
1510            Line(img, new CvPoint(pt1x, pt1y), new CvPoint(pt2x, pt2y), color, thickness);
1511        }
1512        /// <summary>
1513        /// 2点を結ぶ線分を画像上に描画する.
1514        /// </summary>
1515        /// <param name="img">画像</param>
1516        /// <param name="pt1x">線分の1番目の端点x</param>
1517        /// <param name="pt1y">線分の1番目の端点y</param>
1518        /// <param name="pt2x">線分の2番目の端点x</param>
1519        /// <param name="pt2y">線分の2番目の端点y</param>
1520        /// <param name="color">線分の色</param>
1521        /// <param name="thickness">線分の太さ</param>
1522        /// <param name="line_type">線分の種類</param>
1523        public static void Line(this CvArr img, int pt1x, int pt1y, int pt2x, int pt2y, CvScalar color, int thickness, LineType line_type)
1524        {
1525            Line(img, new CvPoint(pt1x, pt1y), new CvPoint(pt2x, pt2y), color, thickness, line_type);
1526        }
1527        /// <summary>
1528        /// 2点を結ぶ線分を画像上に描画する.
1529        /// </summary>
1530        /// <param name="img">画像</param>
1531        /// <param name="pt1x">線分の1番目の端点x</param>
1532        /// <param name="pt1y">線分の1番目の端点y</param>
1533        /// <param name="pt2x">線分の2番目の端点x</param>
1534        /// <param name="pt2y">線分の2番目の端点y</param>
1535        /// <param name="color">線分の色</param>
1536        /// <param name="thickness">線分の太さ</param>
1537        /// <param name="line_type">線分の種類</param>
1538        /// <param name="shift">座標の小数点以下の桁を表すビット数</param>
1539        public static void Line(this CvArr img, int pt1x, int pt1y, int pt2x, int pt2y, CvScalar color, int thickness, LineType line_type, int shift)
1540        {
1541            Line(img, new CvPoint(pt1x, pt1y), new CvPoint(pt2x, pt2y), color, thickness, line_type, shift);
1542        }
1543        /// <summary>
1544        /// 2点を結ぶ線分を画像上に描画する.
1545        /// </summary>
1546        /// <param name="img">画像</param>
1547        /// <param name="pt1">線分の1番目の端点</param>
1548        /// <param name="pt2">線分の2番目の端点</param>
1549        /// <param name="color">線分の色</param>
1550        public static void Line(this CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color)
1551        {
1552            Line(img, pt1, pt2, color, 1, LineType.Link8, 0);
1553        }
1554        /// <summary>
1555        /// 2点を結ぶ線分を画像上に描画する.
1556        /// </summary>
1557        /// <param name="img">画像</param>
1558        /// <param name="pt1">線分の1番目の端点</param>
1559        /// <param name="pt2">線分の2番目の端点</param>
1560        /// <param name="color">線分の色</param>
1561        /// <param name="thickness">線分の太さ</param>
1562        public static void Line(this CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness)
1563        {
1564            Line(img, pt1, pt2, color, thickness, LineType.Link8, 0);
1565        }
1566        /// <summary>
1567        /// 2点を結ぶ線分を画像上に描画する.
1568        /// </summary>
1569        /// <param name="img">画像</param>
1570        /// <param name="pt1">線分の1番目の端点</param>
1571        /// <param name="pt2">線分の2番目の端点</param>
1572        /// <param name="color">線分の色</param>
1573        /// <param name="thickness">線分の太さ</param>
1574        /// <param name="line_type">線分の種類</param>
1575        public static void Line(this CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, LineType line_type)
1576        {
1577            Line(img, pt1, pt2, color, thickness, line_type, 0);
1578        }
1579        /// <summary>
1580        /// 2点を結ぶ線分を画像上に描画する.
1581        /// </summary>
1582        /// <param name="img">画像</param>
1583        /// <param name="pt1">線分の1番目の端点</param>
1584        /// <param name="pt2">線分の2番目の端点</param>
1585        /// <param name="color">線分の色</param>
1586        /// <param name="thickness">線分の太さ</param>
1587        /// <param name="line_type">線分の種類</param>
1588        /// <param name="shift">座標の小数点以下の桁を表すビット数</param>
1589        public static void Line(this CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, LineType line_type, int shift)
1590        {
1591            if (img == null)
1592            {
1593                throw new ArgumentNullException("img");
1594            }
1595            CvDll.cvLine(img.CvPtr, pt1, pt2, color, thickness, line_type, shift);
1596        }
1597        #endregion
1598        #region Load
1599        /// <summary>
1600        /// オブジェクトをファイルから読み込む
1601        /// </summary>
1602        /// <typeparam name="T">読み込むオブジェクトの型</typeparam>
1603        /// <param name="filename">ファイル名</param>
1604        /// <returns>読み込んだオブジェクト</returns>
1605        public static T Load<T>(string filename) where T : ICvPtrHolder
1606        {
1607            string real_name;
1608            return Load<T>(filename, null, null, out real_name);
1609        }
1610        /// <summary>
1611        /// オブジェクトをファイルから読み込む
1612        /// </summary>
1613        /// <typeparam name="T">読み込むオブジェクトの型</typeparam>
1614        /// <param name="filename">ファイル名</param>
1615        /// <param name="memstorage">CvSeqやCvGraph  などの動的構造体のためのメモリストレージ.行列や画像には用いられない.</param>
1616        /// <returns>読み込んだオブジェクト</returns>
1617        public static T Load<T>(string filename, CvMemStorage memstorage) where T : ICvPtrHolder
1618        {
1619            string real_name;
1620            return Load<T>(filename, memstorage, null, out real_name);
1621        }
1622        /// <summary>
1623        /// オブジェクトをファイルから読み込む
1624        /// </summary>
1625        /// <typeparam name="T">読み込むオブジェクトの型</typeparam>
1626        /// <param name="filename">ファイル名</param>
1627        /// <param name="memstorage">CvSeqやCvGraph  などの動的構造体のためのメモリストレージ.行列や画像には用いられない.</param>
1628        /// <param name="name">オブジェクト名(オプション).nullの場合,ファイルストレージにある最初のトップレベルオブジェクトが読み込まれる. </param>
1629        /// <returns>読み込んだオブジェクト</returns>
1630        public static T Load<T>(string filename, CvMemStorage memstorage, string name) where T : ICvPtrHolder
1631        {
1632            string real_name;
1633            return Load<T>(filename, memstorage, name, out real_name);
1634        }
1635        /// <summary>
1636        /// オブジェクトをファイルから読み込む
1637        /// </summary>
1638        /// <typeparam name="T">読み込むオブジェクトの型</typeparam>
1639        /// <param name="filename">ファイル名</param>
1640        /// <param name="memstorage">CvSeqやCvGraphなどの動的構造体のためのメモリストレージ.行列や画像には用いられない.</param>
1641        /// <param name="name">オブジェクト名(オプション).nullの場合,ファイルストレージにある最初のトップレベルオブジェクトが読み込まれる. </param>
1642        /// <param name="real_name">読み込まれたオブジェクトの名前が代入される出力パラメータ(オプション)name=nullの場合に役立つ. </param>
1643        /// <returns>読み込んだオブジェクト</returns>
1644        public static T Load<T>(string filename, CvMemStorage memstorage, string name, out string real_name) where T : ICvPtrHolder
1645        {
1646            if (string.IsNullOrEmpty(filename))
1647                throw new ArgumentNullException("filename");
1648            if (!File.Exists(filename))
1649                throw new FileNotFoundException("", filename);
1650            IntPtr memstoragePtr = (memstorage == null) ? IntPtr.Zero : memstorage.CvPtr;
1651            StringBuilder real_name_sb = new StringBuilder(512);
1652            IntPtr result = CvDll.cvLoad(filename, memstoragePtr, name, real_name_sb);
1653            real_name = real_name_sb.ToString();
1654            return Cast<T>(result);
1655        }
1656        #endregion
1657        #region LoadHaarClassifierCascade
1658#if LANG_JP
1659        /// <summary>
1660        /// ファイルまたはOpenCV 内に組み込まれた分類器データベースから,学習されたカスケード分類器を読み込む
1661        /// </summary>
1662        /// <param name="directory">学習されたカスケード分類器の記述を含むディレクトリ名. </param>
1663        /// <param name="orig_window_size">オブジェクトのオリジナルサイズ(カスケード分類器はこのサイズに合わせて学習される). これはカスケード分類器内に保存されないので,別に指定する必要がある事に注意. </param>
1664        /// <returns></returns>
1665        /// <remarks>この関数は,もはやサポートされない.現在では,オブジェクト検出分類器はディレクトリではなく XML/YAML ファイルに保存される. カスケードをファイルから読み込むためには,関数 cvLoad を用いる.</remarks>
1666#else
1667        /// <summary>
1668        /// Loads a trained cascade classifier from file or the classifier database embedded in OpenCV
1669        /// </summary>
1670        /// <param name="directory">Name of directory containing the description of a trained cascade classifier. </param>
1671        /// <param name="orig_window_size">Original size of objects the cascade has been trained on. Note that it is not stored in the cascade and therefore must be specified separately. </param>
1672        /// <returns></returns>
1673        /// <remarks>The function is obsolete. Nowadays object detection classifiers are stored in XML or YAML files, rather than in directories. To load cascade from a file, use cvLoad function. </remarks>
1674#endif
1675        [Obsolete]
1676        public static CvHaarClassifierCascade LoadHaarClassifierCascade(string directory, CvSize orig_window_size)
1677        {
1678            return CvHaarClassifierCascade.FromDirectory(directory, orig_window_size);
1679        }
1680        #endregion
1681        #region LoadImage
1682#if LANG_JP
1683        /// <summary>
1684        /// 指定されたファイルから画像を読み込み,その画像の参照を返す
1685        /// </summary>
1686        /// <param name="filename">ファイル名</param>
1687        /// <returns>画像への参照</returns>
1688#else
1689        /// <summary>
1690        /// Loads an image from the specified file and returns the reference to the loaded image.
1691        /// </summary>
1692        /// <param name="filename">Name of file to be loaded. </param>
1693        /// <returns>the reference to the loaded image. </returns>
1694#endif
1695        public static IplImage LoadImage(string filename)
1696        {
1697            return LoadImage(filename, LoadMode.Color);
1698        }
1699#if LANG_JP
1700        /// <summary>
1701        /// 指定されたファイルから画像を読み込み,その画像の参照を返す
1702        /// </summary>
1703        /// <param name="filename">ファイル名</param>
1704        /// <param name="flags">読み込む画像がカラー/グレースケールのどちらか,とビット深度を指定する</param>
1705        /// <returns>画像への参照</returns>
1706#else
1707        /// <summary>
1708        /// Loads an image from the specified file and returns the reference to the loaded image.
1709        /// </summary>
1710        /// <param name="filename">Name of file to be loaded. </param>
1711        /// <param name="flags">Specifies colorness and Depth of the loaded image.</param>
1712        /// <returns>the reference to the loaded image. </returns>
1713#endif
1714        public static IplImage LoadImage(string filename, LoadMode flags)
1715        {
1716            if (string.IsNullOrEmpty(filename))
1717                throw new ArgumentNullException("filename");
1718            if (!File.Exists(filename))
1719                throw new FileNotFoundException("", filename);
1720            IntPtr ptr = CvDll.cvLoadImage(filename, flags);
1721            if (ptr == IntPtr.Zero)
1722                return null;
1723            else
1724                return new IplImage(ptr);
1725        }
1726        #endregion
1727        #region LoadImageM
1728#if LANG_JP
1729        /// <summary>
1730        /// 指定されたファイルから画像を読み込み,その画像の参照をCvMat形式で返す
1731        /// </summary>
1732        /// <param name="filename">ファイル名</param>
1733        /// <returns>画像への参照</returns>
1734#else
1735        /// <summary>
1736        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat.
1737        /// </summary>
1738        /// <param name="filename">Name of file to be loaded. </param>
1739        /// <returns>the reference to the loaded image. </returns>
1740#endif
1741        public static CvMat LoadImageM(string filename)
1742        {
1743            return LoadImageM(filename, LoadMode.Color);
1744        }
1745#if LANG_JP
1746        /// <summary>
1747        /// 指定されたファイルから画像を読み込み,その画像の参照をCvMat形式で返す
1748        /// </summary>
1749        /// <param name="filename">ファイル名</param>
1750        /// <param name="flags">読み込む画像がカラー/グレースケールのどちらか,とビット深度を指定する</param>
1751        /// <returns>画像への参照</returns>
1752#else
1753        /// <summary>
1754        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat.
1755        /// </summary>
1756        /// <param name="filename">Name of file to be loaded. </param>
1757        /// <param name="flags">Specifies colorness and Depth of the loaded image.</param>
1758        /// <returns>the reference to the loaded image. </returns>
1759#endif
1760        public static CvMat LoadImageM(string filename, LoadMode flags)
1761        {
1762            if (string.IsNullOrEmpty(filename))
1763                throw new ArgumentNullException("filename");
1764            if (!File.Exists(filename))
1765                throw new FileNotFoundException("", filename);
1766            IntPtr ptr = CvDll.cvLoadImageM(filename, flags);
1767            if (ptr == IntPtr.Zero)
1768                return null;
1769            else
1770                return new CvMat(ptr);
1771        }
1772        #endregion
1773        #region Log
1774        /// <summary>
1775        /// 入力配列のすべての要素の絶対値の自然対数を計算する.
1776        /// dst(I) = log(abs(src(I))), (src(I)!=0の場合),
1777        /// dst(I) = C,  (src(I)=0の場合).
1778        /// ここで,C は大きな負の数である (現在の実装では≈-700).
1779        /// </summary>
1780        /// <param name="src">入力配列</param>
1781        /// <param name="dst">出力配列.倍精度の浮動小数点型(double),または入力配列と同じタイプでなければならない.</param>
1782        public static void Log(this CvArr src, CvArr dst)
1783        {
1784            if (src == null)
1785                throw new ArgumentNullException("src");
1786            if (dst == null)
1787                throw new ArgumentNullException("dst");
1788            CvDll.cvLog(src.CvPtr, dst.CvPtr);
1789        }
1790        #endregion
1791        #region LogPolar
1792#if LANG_JP
1793        /// <summary>
1794        /// 画像を対数極座標(Log-Polar)空間に再マッピングする.
1795        /// この関数は人間の網膜をモデル化したものであり,オブジェクトトラッキング等のための高速なスケーリングと,
1796        /// 回転に不変なテンプレートマッチングに用いることができる.
1797        /// </summary>
1798        /// <param name="src">入力画像</param>
1799        /// <param name="dst">出力画像</param>
1800        /// <param name="center">出力精度が最大となるような変換の中心座標</param>
1801        /// <param name="M">スケーリング係数の大きさ</param>
1802#else
1803        /// <summary>
1804        /// Remaps image to log-polar space.
1805        /// The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking etc.
1806        /// </summary>
1807        /// <param name="src">Source image. </param>
1808        /// <param name="dst">Destination image. </param>
1809        /// <param name="center">The transformation center, where the output precision is maximal. </param>
1810        /// <param name="M">Magnitude scale parameter. See below. </param>
1811#endif
1812        public static void LogPolar(this CvArr src, CvArr dst, CvPoint2D32f center, double M)
1813        {
1814            LogPolar(src, dst, center, M);
1815        }
1816#if LANG_JP
1817        /// <summary>
1818        /// 画像を対数極座標(Log-Polar)空間に再マッピングする.
1819        /// この関数は人間の網膜をモデル化したものであり,オブジェクトトラッキング等のための高速なスケーリングと,
1820        /// 回転に不変なテンプレートマッチングに用いることができる.
1821        /// </summary>
1822        /// <param name="src">入力画像</param>
1823        /// <param name="dst">出力画像</param>
1824        /// <param name="center">出力精度が最大となるような変換の中心座標</param>
1825        /// <param name="M">スケーリング係数の大きさ</param>
1826        /// <param name="flags">補間方法</param>
1827#else
1828        /// <summary>
1829        /// Remaps image to log-polar space.
1830        /// The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking etc.
1831        /// </summary>
1832        /// <param name="src">Source image. </param>
1833        /// <param name="dst">Destination image. </param>
1834        /// <param name="center">The transformation center, where the output precision is maximal. </param>
1835        /// <param name="M">Magnitude scale parameter. See below. </param>
1836        /// <param name="flags">A combination of interpolation method and the optional flags.</param>
1837#endif
1838        public static void LogPolar(this CvArr src, CvArr dst, CvPoint2D32f center, double M, Interpolation flags)
1839        {
1840            if (src == null)
1841                throw new ArgumentNullException("src");
1842            if (dst == null)
1843                throw new ArgumentNullException("dst");
1844            CvDll.cvLogPolar(src.CvPtr, dst.CvPtr, center, M, flags);
1845        }
1846        #endregion
1847        #region LUT
1848        /// <summary>
1849        /// 出力配列の各要素値をルックアップテーブルを用いて決定する.
1850        /// </summary>
1851        /// <param name="src">入力配列(各要素は8ビットデータ).</param>
1852        /// <param name="dst">出力配列(任意のデプス,入力配列と同じチャンネル数).</param>
1853        /// <param name="lut">要素数が256であるルックアップテーブル(出力配列と同じデプスでなければならない).マルチチャンネルの入力/出力配列の場合,テーブルはシングルチャンネル(この場合すべてのチャンネル対して,同じテーブルを使う)か,入力/出力配列と同じチャンネル数でなければならない.</param>
1854        public static void LUT(this CvArr src, CvArr dst, CvArr lut)
1855        {
1856            if (src == null)
1857                throw new ArgumentNullException("src");
1858            if (dst == null)
1859                throw new ArgumentNullException("dst");
1860            if (lut == null)
1861                throw new ArgumentNullException("lut");
1862            CvDll.cvLUT(src.CvPtr, dst.CvPtr, lut.CvPtr);
1863        }
1864        /// <summary>
1865        /// 出力配列の各要素値をルックアップテーブルを用いて決定する.ルックアップテーブルが配列で指定できる簡易バージョン.
1866        /// </summary>
1867        /// <param name="src">入力配列(各要素は8ビットデータ)</param>
1868        /// <param name="dst">出力配列(任意のデプス,入力配列と同じチャンネル数)</param>
1869        /// <param name="lut">要素数が256であるルックアップテーブル</param>
1870        public static void LUT(this CvArr src, CvArr dst, byte[] lut)
1871        {
1872            if (src == null)
1873                throw new ArgumentNullException("src");
1874            if (dst == null)
1875                throw new ArgumentNullException("dst");
1876            if (lut == null)
1877                throw new ArgumentNullException("lut");
1878            if (lut.Length != 256)
1879                throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
1880            if (dst.ElemChannels != 1)
1881            {
1882                throw new NotImplementedException();
1883            }
1884
1885            using (CvMat lutMat = new CvMat(256, 1, MatrixType.U8C1, lut))
1886            {
1887                CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
1888            }
1889        }
1890        /// <summary>
1891        /// 出力配列の各要素値をルックアップテーブルを用いて決定する.ルックアップテーブルが配列で指定できる簡易バージョン.
1892        /// </summary>
1893        /// <param name="src">入力配列(各要素は8ビットデータ)</param>
1894        /// <param name="dst">出力配列(任意のデプス,入力配列と同じチャンネル数)</param>
1895        /// <param name="lut">要素数が256であるルックアップテーブル</param>
1896        public static void LUT(this CvArr src, CvArr dst, Int16[] lut)
1897        {
1898            if (src == null)
1899                throw new ArgumentNullException("src");
1900            if (dst == null)
1901                throw new ArgumentNullException("dst");
1902            if (lut == null)
1903                throw new ArgumentNullException("lut");
1904            if (lut.Length != 256)
1905                throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
1906            if (dst.ElemChannels != 1)
1907            {
1908                throw new NotImplementedException();
1909            }
1910
1911            using (CvMat lutMat = new CvMat(256, 1, MatrixType.S16C1, lut))
1912            {
1913                CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
1914            }
1915        }
1916        /// <summary>
1917        /// 出力配列の各要素値をルックアップテーブルを用いて決定する.ルックアップテーブルが配列で指定できる簡易バージョン.
1918        /// </summary>
1919        /// <param name="src">入力配列(各要素は8ビットデータ)</param>
1920        /// <param name="dst">出力配列(任意のデプス,入力配列と同じチャンネル数)</param>
1921        /// <param name="lut">要素数が256であるルックアップテーブル</param>
1922        public static void LUT(CvArr src, CvArr dst, int[] lut)
1923        {
1924            if (src == null)
1925                throw new ArgumentNullException("src");
1926            if (dst == null)
1927                throw new ArgumentNullException("dst");
1928            if (lut == null)
1929                throw new ArgumentNullException("lut");
1930            if (lut.Length != 256)
1931                throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
1932            if (dst.ElemChannels != 1)
1933            {
1934                throw new NotImplementedException();
1935            }
1936
1937            using (CvMat lutMat = new CvMat(256, 1, MatrixType.S32C1, lut))
1938            {
1939                CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
1940            }
1941        }
1942        /// <summary>
1943        /// 出力配列の各要素値をルックアップテーブルを用いて決定する.ルックアップテーブルが配列で指定できる簡易バージョン.
1944        /// </summary>
1945        /// <param name="src">入力配列(各要素は8ビットデータ)</param>
1946        /// <param name="dst">出力配列(任意のデプス,入力配列と同じチャンネル数)</param>
1947        /// <param name="lut">要素数が256であるルックアップテーブル</param>
1948        public static void LUT(CvArr src, CvArr dst, float[] lut)
1949        {
1950            if (src == null)
1951                throw new ArgumentNullException("src");
1952            if (dst == null)
1953                throw new ArgumentNullException("dst");
1954            if (lut == null)
1955                throw new ArgumentNullException("lut");
1956            if (lut.Length != 256)
1957                throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
1958            if (dst.ElemChannels != 1)
1959            {
1960                throw new NotImplementedException();
1961            }
1962
1963            using (CvMat lutMat = new CvMat(256, 1, MatrixType.F32C1, lut))
1964            {
1965                CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
1966            }
1967        }
1968        /// <summary>
1969        /// 出力配列の各要素値をルックアップテーブルを用いて決定する.ルックアップテーブルが配列で指定できる簡易バージョン.
1970        /// </summary>
1971        /// <param name="src">入力配列(各要素は8ビットデータ)</param>
1972        /// <param name="dst">出力配列(任意のデプス,入力配列と同じチャンネル数)</param>
1973        /// <param name="lut">要素数が256であるルックアップテーブル</param>
1974        public static void LUT(CvArr src, CvArr dst, double[] lut)
1975        {
1976            if (src == null)
1977                throw new ArgumentNullException("src");
1978            if (dst == null)
1979                throw new ArgumentNullException("dst");
1980            if (lut == null)
1981                throw new ArgumentNullException("lut");
1982            if (lut.Length != 256)
1983                throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
1984            if (dst.ElemChannels != 1)
1985            {
1986                throw new NotImplementedException();
1987            }
1988
1989            using (CvMat lutMat = new CvMat(256, 1, MatrixType.F64C1, lut))
1990            {
1991                CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
1992            }
1993        }
1994        #endregion
1995        #region MakeScanlines
1996        /// <summary>
1997        /// 基礎行列から二つのカメラ間のスキャンライン座標を計算する
1998        /// </summary>
1999        /// <param name="matrix">基礎行列</param>
2000        /// <param name="img_size">画像のサイズ</param>
2001        /// <param name="scanlines1">第1画像の計算されたスキャンラインが格納される配列へのポインタ</param>
2002        /// <param name="scanlines2">第2画像の計算されたスキャンラインが格納される配列へのポインタ</param>
2003        /// <param name="lengths1">第1画像スキャンラインの長さ(ピクセル単位)が格納される配列へのポインタ</param>
2004        /// <param name="lengths2">第2画像スキャンラインの長さ(ピクセル単位)が格納される配列へのポインタ</param>
2005        /// <param name="line_count">スキャンライン数を格納する変数へのポインタ</param>
2006        public static void MakeScanlines(double[,] matrix, CvSize img_size, int[] scanlines1, int[] scanlines2, int[] lengths1, int[] lengths2, out int line_count)
2007        {
2008            CvDll.cvMakeScanlines(matrix, img_size, scanlines1, scanlines2, lengths1, lengths2, out line_count);
2009        }
2010        #endregion
2011        #region Mat
2012        /// <summary>
2013        /// 行列ヘッダを初期化する(軽量版)
2014        /// </summary>
2015        /// <param name="rows">画像の幅と高さ</param>
2016        /// <param name="cols">画像のカラーデプス</param>
2017        /// <param name="type">チャンネル数</param>
2018        /// <returns>初期化された行列ヘッダ</returns>
2019        public static CvMat Mat(int rows, int cols, MatrixType type)
2020        {
2021            return new CvMat(rows, cols, type);
2022        }
2023        /// <summary>
2024        /// 行列ヘッダを初期化する(軽量版)
2025        /// </summary>
2026        /// <param name="rows">画像の幅と高さ</param>
2027        /// <param name="cols">画像のカラーデプス</param>
2028        /// <param name="type">チャンネル数</param>
2029        /// <param name="data">行列のヘッダで指定されるデータ配列. 長さがrows*cols*channelsの1次元配列を指定する.</param>
2030        /// <returns>初期化された行列ヘッダ</returns>
2031        public static CvMat Mat<T>(int rows, int cols, MatrixType type, T[] data) where T : struct
2032        {
2033            return new CvMat(rows, cols, type, data);
2034        }
2035        #endregion
2036        #region MatchContourTrees
2037#if LANG_JP
2038        /// <summary>
2039        /// ツリー表現を使って2つの輪郭を比較する
2040        /// </summary>
2041        /// <param name="tree1">一つ目の輪郭の二分木.</param>
2042        /// <param name="tree2">二つ目の輪郭の二分木.</param>
2043        /// <param name="method">類似度.I1のみ利用可能.</param>
2044        /// <param name="threshold">類似度の閾値.</param>
2045        /// <returns></returns>
2046#else
2047        /// <summary>
2048        /// Compares two contours using their tree representations.
2049        /// </summary>
2050        /// <param name="tree1">First contour tree. </param>
2051        /// <param name="tree2">Second contour tree. </param>
2052        /// <param name="method">Similarity measure, only I1 is supported. </param>
2053        /// <param name="threshold">Similarity threshold. </param>
2054        /// <returns></returns>
2055#endif
2056        public static double MatchContourTrees(CvContourTree tree1, CvContourTree tree2, ContourTreesMatchMethod method, double threshold)
2057        {
2058            if (tree1 == null)
2059                throw new ArgumentNullException("tree1");
2060            if (tree2 == null)
2061                throw new ArgumentNullException("tree2");
2062            return CvDll.cvMatchContourTrees(tree1.CvPtr, tree2.CvPtr, method, threshold);
2063        }
2064        #endregion
2065        #region MatchShapes
2066#if LANG_JP
2067        /// <summary>
2068        /// 二つの形状を比較する
2069        /// </summary>
2070        /// <param name="object1">1番目の輪郭,あるいはグレースケール画像.</param>
2071        /// <param name="object2">2番目の輪郭,あるいはグレースケール画像.</param>
2072        /// <param name="method">比較方法.</param>
2073        /// <returns></returns>
2074#else
2075        /// <summary>
2076        /// Compares two shapes.
2077        /// </summary>
2078        /// <param name="object1">First contour or grayscale image.</param>
2079        /// <param name="object2">Second contour or grayscale image.</param>
2080        /// <param name="method">Comparison method.</param>
2081        /// <returns></returns>
2082#endif
2083        public static double MatchShapes(CvArr object1, CvArr object2, MatchShapesMethod method)
2084        {
2085            return MatchShapes(object1, object2, method, 0);
2086        }
2087#if LANG_JP
2088        /// <summary>
2089        /// 二つの形状を比較する
2090        /// </summary>
2091        /// <param name="object1">1番目の輪郭,あるいはグレースケール画像.</param>
2092        /// <param name="object2">2番目の輪郭,あるいはグレースケール画像.</param>
2093        /// <param name="method">比較方法.</param>
2094        /// <param name="parameter">それぞれの比較手法特有のパラメータ(現在未使用).</param>
2095        /// <returns></returns>
2096#else
2097        /// <summary>
2098        /// Compares two shapes.
2099        /// </summary>
2100        /// <param name="object1">First contour or grayscale image.</param>
2101        /// <param name="object2">Second contour or grayscale image.</param>
2102        /// <param name="method">Comparison method.</param>
2103        /// <param name="parameter">Method-specific parameter (is not used now). </param>
2104        /// <returns></returns>
2105#endif
2106        public static double MatchShapes(CvArr object1, CvArr object2, MatchShapesMethod method, double parameter)
2107        {
2108            if (object1 == null)
2109                throw new ArgumentNullException("object1");
2110            if (object2 == null)
2111                throw new ArgumentNullException("object2");
2112            return CvDll.cvMatchShapes(object1.CvPtr, object2.CvPtr, method, parameter);
2113        }
2114        #endregion
2115        #region MatchTemplate
2116#if LANG_JP
2117        /// <summary>
2118        /// テンプレートと重なった画像領域を比較する.
2119        /// templを,image全体に対してスライドさせ,それとサイズ w×h で重なる領域とを指定された方法で比較し,その結果を result に保存する.
2120        /// </summary>
2121        /// <param name="image">テンプレートマッチングを行う画像. 8ビットか32ビット浮動小数点型でなければならない.</param>
2122        /// <param name="templ">探索用テンプレート.画像より大きくてはならない,かつ画像と同じタイプである必要がある. </param>
2123        /// <param name="result">比較結果のマップ.シングルチャンネルの32ビット浮動小数点型データ.image が W×H で templ が w×h ならば, result は W-w+1×H-h+1のサイズが必要. </param>
2124        /// <param name="method">テンプレートマッチングの方法(以下を参照).</param>
2125#else
2126        /// <summary>
2127        /// Compares template against overlapped image regions.
2128        /// </summary>
2129        /// <param name="image">Image where the search is running. It should be 8-bit or 32-bit floating-point. </param>
2130        /// <param name="templ">Searched template; must be not greater than the source image and the same data type as the image. </param>
2131        /// <param name="result">A map of comparison results; single-channel 32-bit floating-point. If image is W×H and templ is w×h then result must be W-w+1×H-h+1. </param>
2132        /// <param name="method">Specifies the way the template must be compared with image regions. </param>
2133#endif
2134        public static void MatchTemplate(this CvArr image, CvArr templ, CvArr result, MatchTemplateMethod method)
2135        {
2136            if (image == null)
2137                throw new ArgumentNullException("image");
2138            if (templ == null)
2139                throw new ArgumentNullException("templ");
2140            if (result == null)
2141                throw new ArgumentNullException("result");
2142            CvDll.cvMatchTemplate(image.CvPtr, templ.CvPtr, result.CvPtr, method);
2143        }
2144        #endregion
2145        #region MatMul
2146        /// <summary>
2147        /// 行列の乗算を行う.
2148        /// dst = A*B.
2149        /// 全ての行列は同じデータタイプ,同じサイズである必要がある.実数あるいは複素数の浮動小数点型の行列がサポートされている.
2150        /// </summary>
2151        /// <param name="src1">1番目の入力配列</param>
2152        /// <param name="src2">2番目の入力配列</param>
2153        /// <param name="dst">出力配列</param>
2154        public static void MatMul(CvArr src1, CvArr src2, CvArr dst)
2155        {
2156            MatMulAdd(src1, src2, null, dst);
2157        }
2158        /// <summary>
2159        /// 行列の乗算を行う.
2160        /// dst = A*B + C, C is optional.
2161        /// 全ての行列は同じデータタイプ,同じサイズである必要がある.実数あるいは複素数の浮動小数点型の行列がサポートされている.
2162        /// </summary>
2163        /// <param name="src1">1番目の入力配列</param>
2164        /// <param name="src2">2番目の入力配列</param>
2165        /// <param name="src3">3番目の入力配列(シフト用).もしシフトしない場合はNULLにできる</param>
2166        /// <param name="dst">出力配列</param>
2167        public static void MatMulAdd(CvArr src1, CvArr src2, CvArr src3, CvArr dst)
2168        {
2169            if (src1 == null)
2170                throw new ArgumentNullException("src1");
2171            if (src2 == null)
2172                throw new ArgumentNullException("src2");
2173            if (dst == null)
2174                throw new ArgumentNullException("dst");
2175            GEMM(src1, src2, 1, src3, 1, dst, GemmOperation.Zero);
2176        }
2177        #endregion
2178        #region Max
2179        /// <summary>
2180        /// 二つの配列の各要素についての最大値を求める.
2181        /// dst(I)=max(src1(I), src2(I))
2182        /// すべての配列はシングルチャンネルで,タイプ,配列のサイズ(またはROIのサイズ)は同じでなければならない.
2183        /// </summary>
2184        /// <param name="src1">1番目の入力配列</param>
2185        /// <param name="src2">2番目の入力配列</param>
2186        /// <param name="dst">出力配列</param>
2187        public static void Max(this CvArr src1, CvArr src2, CvArr dst)
2188        {
2189            if (src1 == null)
2190                throw new ArgumentNullException("src1");
2191            if (src2 == null)
2192                throw new ArgumentNullException("src2");
2193            if (dst == null)
2194                throw new ArgumentNullException("dst");
2195            CvDll.cvMax(src1.CvPtr, src2.CvPtr, dst.CvPtr);
2196        }
2197        #endregion
2198        #region MaxRect
2199#if LANG_JP
2200        /// <summary>
2201        ///
2202        /// </summary>
2203        /// <param name="rect1"></param>
2204        /// <param name="rect2"></param>
2205#else
2206        /// <summary>
2207        /// Finds bounding rectangle for two given rectangles
2208        /// </summary>
2209        /// <param name="rect1">First rectangle </param>
2210        /// <param name="rect2">Second rectangle </param>
2211#endif
2212        public static CvRect MaxRect(CvRect rect1, CvRect rect2)
2213        {
2214            return CvDll.cvMaxRect(ref rect1, ref rect2);
2215        }
2216        #endregion
2217        #region MaxS
2218        /// <summary>
2219        /// 配列の各要素とスカラーについての最大値を求める.
2220        /// dst(I)=max(src(I), value)
2221        /// すべての配列はシングルチャンネルで,タイプ,配列のサイズ(またはROIのサイズ)は同じでなければならない.
2222        /// </summary>
2223        /// <param name="src">入力配列</param>
2224        /// <param name="value">スカラー</param>
2225        /// <param name="dst">出力配列</param>
2226        public static void MaxS(this CvArr src, double value, CvArr dst)
2227        {
2228            if (src == null)
2229                throw new ArgumentNullException("src1");
2230            if (dst == null)
2231                throw new ArgumentNullException("dst");
2232            CvDll.cvMaxS(src.CvPtr, value, dst.CvPtr);
2233        }
2234        #endregion
2235        #region MeanShift
2236#if LANG_JP
2237        /// <summary>
2238        /// バックプロジェクションでのオブジェクトの中心を検出する
2239        /// </summary>
2240        /// <param name="prob_image">オブジェクトヒストグラムのバックプロジェクション</param>
2241        /// <param name="window">初期探索ウィンドウ</param>
2242        /// <param name="criteria">ウィンドウ探索を終了するための条件</param>
2243        /// <param name="comp">結果として得られる構造体.収束した探索ウィンドウの座標(comp->rect フィールド),および ウィンドウ内の全ピクセルの合計値(comp->area フィールド)が含まれる.</param>
2244        /// <returns></returns>
2245#else
2246        /// <summary>
2247        /// Finds object center on back projection
2248        /// </summary>
2249        /// <param name="prob_image">Back projection of object histogram (see cvCalcBackProject). </param>
2250        /// <param name="window">Initial search window. </param>
2251        /// <param name="criteria">Criteria applied to determine when the window search should be finished. </param>
2252        /// <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>
2253        /// <returns>The function returns number of iterations made within cvMeanShift. </returns>
2254#endif
2255        public static int MeanShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, CvConnectedComp comp)
2256        {
2257            if (prob_image == null)
2258            {
2259                throw new ArgumentNullException("prob_image");
2260            }
2261            if (comp == null)
2262            {
2263                throw new ArgumentNullException("comp");
2264            }
2265            return CvDll.cvMeanShift(prob_image.CvPtr, window, criteria, comp.CvPtr);
2266        }
2267        #endregion
2268        #region MemStorageAlloc
2269        /// <summary>
2270        /// ストレージ内にメモリバッファを確保する.バッファサイズは,ストレージのブロックサイズを超えてはいけない.
2271        /// 超えた場合にはランタイムエラーが発生する.バッファアドレスは,CV_STRUCT_ALIGN(現時点では=sizeof(double))バイトにアライメントされる.
2272        /// </summary>
2273        /// <param name="storage">ストレージへの参照</param>
2274        /// <param name="size">バッファサイズ</param>
2275        /// <returns></returns>
2276        public static IntPtr MemStorageAlloc(CvMemStorage storage, uint size)
2277        {
2278            if (storage == null)
2279            {
2280                throw new ArgumentNullException("storage");
2281            }
2282            return CvDll.cvMemStorageAlloc(storage.CvPtr, size);
2283        }
2284        #endregion
2285        #region Merge
2286        /// <summary>
2287        /// 複数のシングルチャネルの配列からマルチチャンネル配列を構成する.または,配列に一つのシングルチャンネルを挿入する.
2288        /// もし出力配列がNチャンネルで,N個の入力チャンネルが null でないとき,これらのすべては出力配列にコピーされる.
2289        /// そうでなく,一つの入力配列のみが null でなければ,この特定のチャンネルが出力配列にコピーされ,
2290        /// このいずれもでない場合はエラーとなる.N番目以降の入力チャンネルは常に null でなくてはならない.
2291        /// </summary>
2292        /// <param name="src0">入力配列1</param>
2293        /// <param name="src1">入力配列2</param>
2294        /// <param name="src2">入力配列3</param>
2295        /// <param name="src3">入力配列4</param>
2296        /// <param name="dst">出力配列</param>
2297        public static void Merge(CvArr src0, CvArr src1, CvArr src2, CvArr src3, CvArr dst)
2298        {
2299            if (dst == null)
2300            {
2301                throw new ArgumentNullException("dst");
2302            }
2303            IntPtr p0 = (src0 == null) ? IntPtr.Zero : src0.CvPtr;
2304            IntPtr p1 = (src1 == null) ? IntPtr.Zero : src1.CvPtr;
2305            IntPtr p2 = (src2 == null) ? IntPtr.Zero : src2.CvPtr;
2306            IntPtr p3 = (src3 == null) ? IntPtr.Zero : src3.CvPtr;
2307            CvDll.cvMerge(p0, p1, p2, p3, dst.CvPtr);
2308        }
2309        #endregion
2310        #region mGet
2311        /// <summary>
2312        /// シングルチャンネル浮動小数点型行列の場合における,cvGetReal2Dの高速化版関数である.
2313        /// </summary>
2314        /// <param name="mat">入力行列</param>
2315        /// <param name="row">行の0を基準としたインデックス</param>
2316        /// <param name="col">列の0を基準としたインデックス</param>
2317        /// <returns>指定した要素の値</returns>
2318        public static double mGet(this CvMat mat, int row, int col)
2319        {
2320            return CvInline.cvmGet(mat.CvPtr, row, col);
2321        }
2322        #endregion
2323        #region Min
2324        /// <summary>
2325        /// 二つの配列の各要素についての最小値を求める.
2326        /// dst(I)=min(src1(I), src2(I))
2327        /// すべての配列はシングルチャンネルで,タイプ,配列のサイズ(またはROIのサイズ)は同じでなければならない.
2328        /// </summary>
2329        /// <param name="src1">1番目の入力配列</param>
2330        /// <param name="src2">2番目の入力配列</param>
2331        /// <param name="dst">出力配列</param>
2332        public static void Min(this CvArr src1, CvArr src2, CvArr dst)
2333        {
2334            if (src1 == null)
2335                throw new ArgumentNullException("src1");
2336            if (src2 == null)
2337                throw new ArgumentNullException("src2");
2338            if (dst == null)
2339                throw new ArgumentNullException("dst");
2340            CvDll.cvMin(src1.CvPtr, src2.CvPtr, dst.CvPtr);
2341        }
2342        #endregion
2343        #region MinMaxLoc
2344        /// <summary>
2345        /// 配列要素の中から最小値・最大値とその位置を求める.
2346        /// 各極値は配列全体または選択されたROI(IplImageの場合)をスキャンして求める.
2347        /// マルチチャンネル配列の場合,入力は COI がセットされた IplImage データタイプでなければならない.
2348        /// </summary>
2349        /// <param name="arr">入力配列(シングルチャンネルまたはCOIがセットされたマルチチャンネル)</param>
2350        /// <param name="min_val">戻り値の最小値</param>
2351        /// <param name="max_val">戻り値の最大値</param>
2352        public static void MinMaxLoc(this CvArr arr, out double min_val, out double max_val)
2353        {
2354            CvPoint min_loc, max_loc;
2355            MinMaxLoc(arr, out min_val, out max_val, out min_loc, out max_loc, null);
2356        }
2357        /// <summary>
2358        /// 配列要素の中から最小値・最大値とその位置を求める.
2359        /// 各極値は配列全体または選択されたROI(IplImageの場合)をスキャンして求める.
2360        /// マルチチャンネル配列の場合,入力は COI がセットされた IplImage データタイプでなければならない.
2361        /// 多次元配列の場合は,min_loc->xと max_loc->yには,極値の座標がそのまま入る.
2362        /// </summary>
2363        /// <param name="arr">入力配列(シングルチャンネルまたはCOIがセットされたマルチチャンネル)</param>
2364        /// <param name="min_val">戻り値の最小値</param>
2365        /// <param name="max_val">戻り値の最大値</param>
2366        /// <param name="min_loc">戻り値の最小値を持つ位置</param>
2367        /// <param name="max_loc">戻り値の最大値を持つ位置</param>
2368        public static void MinMaxLoc(this CvArr arr, out double min_val, out double max_val, out CvPoint min_loc, out CvPoint max_loc)
2369        {
2370            MinMaxLoc(arr, out min_val, out max_val, out min_loc, out max_loc, null);
2371        }
2372        /// <summary>
2373        /// 配列要素の中から最小値・最大値とその位置を求める.
2374        /// 各極値は配列全体または選択されたROI(IplImageの場合)をスキャンして求める.
2375        /// mask が NULL でない場合は,指定された領域のみをスキャンする.
2376        /// マルチチャンネル配列の場合,入力は COI がセットされた IplImage データタイプでなければならない.
2377        /// 多次元配列の場合は,min_loc->xと max_loc->yには,極値の座標がそのまま入る.
2378        /// </summary>
2379        /// <param name="arr">入力配列(シングルチャンネルまたはCOIがセットされたマルチチャンネル)</param>
2380        /// <param name="min_val">戻り値の最小値</param>
2381        /// <param name="max_val">戻り値の最大値</param>
2382        /// <param name="min_loc">戻り値の最小値を持つ位置</param>
2383        /// <param name="max_loc">戻り値の最大値を持つ位置</param>
2384        /// <param name="mask">部分配列を指定するためのオプションのマスク</param>
2385        public static void MinMaxLoc(this CvArr arr, out double min_val, out double max_val, out CvPoint min_loc, out CvPoint max_loc, CvArr mask)
2386        {
2387            if (arr == null)
2388            {
2389                throw new ArgumentNullException("arr");
2390            }
2391            double _min_val = 0;
2392            double _max_val = 0;
2393            CvPoint _min_loc = new CvPoint();
2394            CvPoint _max_loc = new CvPoint();
2395            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
2396            CvDll.cvMinMaxLoc(arr.CvPtr, ref _min_val, ref _max_val, ref _min_loc, ref _max_loc, maskPtr);
2397            min_val = _min_val;
2398            max_val = _max_val;
2399            min_loc = _min_loc;
2400            max_loc = _max_loc;
2401        }
2402        #endregion
2403        #region MinAreaRect2
2404#if LANG_JP
2405        /// <summary>
2406        /// 与えられた2次元の点列を囲む最小矩形を求める
2407        /// </summary>
2408        /// <param name="points">点のシーケンスまたは配列</param>
2409        /// <returns>2次元の点列に対する最小矩形</returns>
2410#else
2411        /// <summary>
2412        /// Finds circumscribed rectangle of minimal area for given 2D point set
2413        /// </summary>
2414        /// <param name="points">Sequence or array of points. </param>
2415        /// <returns>The function cvMinAreaRect2 finds a circumscribed rectangle of the minimal area for 2D point set by building convex hull for the set and applying rotating calipers technique to the hull.</returns>
2416#endif
2417        public static CvBox2D MinAreaRect2(this CvArr points)
2418        {
2419            return MinAreaRect2(points, null);
2420        }
2421#if LANG_JP
2422        /// <summary>
2423        /// 与えられた2次元の点列を囲む最小矩形を求める
2424        /// </summary>
2425        /// <param name="points">点のシーケンスまたは配列</param>
2426        /// <param name="storage">一時的なメモリストレージ</param>
2427        /// <returns>2次元の点列に対する最小矩形</returns>
2428#else
2429        /// <summary>
2430        /// Finds circumscribed rectangle of minimal area for given 2D point set
2431        /// </summary>
2432        /// <param name="points">Sequence or array of points. </param>
2433        /// <param name="storage">The point tested against the contour.</param>
2434        /// <returns>The function cvMinAreaRect2 finds a circumscribed rectangle of the minimal area for 2D point set by building convex hull for the set and applying rotating calipers technique to the hull.</returns>
2435#endif
2436        public static CvBox2D MinAreaRect2(this CvArr points, CvMemStorage storage)
2437        {
2438            if (points == null)
2439                throw new ArgumentNullException("points");
2440            IntPtr storage_ptr = (storage == null) ? IntPtr.Zero : storage.CvPtr;
2441            return CvDll.cvMinAreaRect2(points.CvPtr, storage_ptr);
2442        }
2443        #endregion
2444        #region MinEnclosingCircle
2445#if LANG_JP
2446        /// <summary>
2447        /// 与えられた2次元の点列を囲む最小円を求める
2448        /// </summary>
2449        /// <param name="points">2次元の点のシーケンスまたは配列.</param>
2450        /// <param name="center">出力パラメータ.囲む円の中心.</param>
2451        /// <param name="radius">出力パラメータ.囲む円の半径.</param>
2452        /// <returns>結果の円が全ての入力点を含む場合はtrueを返し, それ以外(すなわちアルゴリズムの失敗)の場合はfalseを返す.</returns>
2453#else
2454        /// <summary>
2455        /// Finds circumscribed rectangle of minimal area for given 2D point set
2456        /// </summary>
2457        /// <param name="points">Sequence or array of 2D points. </param>
2458        /// <param name="center">Output parameter. The center of the enclosing circle. </param>
2459        /// <param name="radius">Output parameter. The radius of the enclosing circle. </param>
2460        /// <returns>The function cvMinEnclosingCircle finds the minimal circumscribed circle for 2D point set using iterative algorithm.
2461        /// It returns true if the resultant circle contains all the input points and false otherwise (i.e. algorithm failed). </returns>
2462#endif
2463        public static bool MinEnclosingCircle(this CvArr points, out CvPoint2D32f center, out float radius)
2464        {
2465            if (points == null)
2466                throw new ArgumentNullException("points");
2467            center = new CvPoint2D32f();
2468            radius = default(float);
2469            return CvDll.cvMinEnclosingCircle(points.CvPtr, ref center, ref radius);
2470        }
2471        #endregion
2472        #region MinS
2473        /// <summary>
2474        /// 配列の各要素とスカラーについての最小値を求める.
2475        /// dst(I)=min(src(I), value)
2476        /// すべての配列はシングルチャンネルで,タイプ,配列のサイズ(またはROIのサイズ)は同じでなければならない.
2477        /// </summary>
2478        /// <param name="src">入力配列</param>
2479        /// <param name="value">スカラー</param>
2480        /// <param name="dst">出力配列</param>
2481        public static void MinS(this CvArr src, double value, CvArr dst)
2482        {
2483            if (src == null)
2484                throw new ArgumentNullException("src1");
2485            if (dst == null)
2486                throw new ArgumentNullException("dst");
2487            CvDll.cvMinS(src.CvPtr, value, dst.CvPtr);
2488        }
2489        #endregion
2490        #region MixChannels
2491        /// <summary>
2492        /// cvSplit,cvMerge,および cvCvtColorのいくつかの書式の汎用形である.
2493        /// これは,平面の順番の変更,アルファチャネルの追加や削除,1枚の平面や複数平面の抽出や挿入などに用いられる.
2494        /// </summary>
2495        /// <param name="src">入力配列の配列</param>
2496        /// <param name="dst">出力配列の配列</param>
2497        /// <param name="from_to">コピーされる平面(チャンネル)のインデックスのペア配列. from_to[k*2]は入力平面の0を基準としたインデックスで,from_to[k*2+1]は出力平面のインデックス.ここで,入力及び出力配列すべてについて,各平面への連続的な番号付けが行われる.from_to[k*2]が負のとき,対応する出力平面は0で埋められる.</param>
2498        /// <param name="pair_count">from_toのペア数,またはコピーされた平面の数.</param>
2499        /// <example>
2500        /// CvMat* rgba = cvCreateMat( 100, 100, CV_8UC4 );
2501        /// CvMat* bgr = cvCreateMat( rgba-&gt;rows, rgba-&gt;cols, CV_8UC3 );
2502        /// CvMat* alpha = cvCreateMat( rgba-&gt;rows, rgba-&gt;cols, CV_8UC1 );
2503        /// CvArr* out[] = { bgr, alpha };
2504        /// int from_to[] = { 0, 2, 1, 1, 2, 0, 3, 3 };
2505        /// cvSet( rgba, cvScalar(1,2,3,4) );
2506        /// cvMixChannels( (const CvArr**)&amp;rgba, 1, out, 2, from_to, 4 );   
2507        /// </example>
2508        public static void MixChannels(CvArr[] src, CvArr[] dst, int[] from_to, int pair_count)
2509        {
2510            if (src == null || src.Length == 0)
2511                throw new ArgumentNullException("src");
2512            if (dst == null || dst.Length == 0)
2513                throw new ArgumentNullException("dst");
2514            if (from_to == null)
2515                throw new ArgumentNullException("from_to");
2516
2517            IntPtr[] srcPtr = new IntPtr[src.Length];
2518            IntPtr[] dstPtr = new IntPtr[dst.Length];
2519            for (int i = 0; i < src.Length; i++)
2520                srcPtr[i] = src[i].CvPtr;
2521            for (int i = 0; i < dst.Length; i++)
2522                dstPtr[i] = dst[i].CvPtr;
2523
2524            CvDll.cvMixChannels(srcPtr, src.Length, dstPtr, dst.Length, from_to, pair_count);
2525        }
2526        #endregion
2527        #region Moments
2528#if LANG_JP
2529        /// <summary>
2530        /// ポリゴンまたはラスタ形状の3次までのモーメントを計算する
2531        /// </summary>
2532        /// <param name="image">画像(1チャンネル,あるいはCOIをもつ3チャンネル画像) あるいはポリゴン (CvSeqで表される点群,または点のベクトル).</param>
2533        /// <param name="moments">画像モーメントを表す構造体への参照</param>
2534        /// <param name="isBinary">(画像の場合のみ)このフラグがtrueの場合,値0のピクセルは0として,その他のピクセル値は1として扱われる. </param>
2535        /// <returns></returns>
2536#else
2537        /// <summary>
2538        /// Moments
2539        /// </summary>
2540        /// <param name="image">Image (1-channel or 3-channel with COI set) or polygon (CvSeq of points or a vector of points)</param>
2541        /// <param name="moments">Returned moment state structure</param>
2542        /// <param name="isBinary">(For images only) If the flag is non-zero, all the zero pixel values are treated as zeroes, all the others are treated as 1’s</param>
2543        /// <returns></returns>
2544#endif
2545        public static double Moments(this CvArr image, out CvMoments moments, bool isBinary)
2546        {
2547            if (image == null)
2548            {
2549                throw new ArgumentNullException("contour");
2550            }
2551            //return CvDll.cvMoments(image.CvPtr, moments.CvPtr, isBinary);
2552            moments = new CvMoments();
2553            return CvDll.cvMoments(image.CvPtr, moments, isBinary);
2554        }
2555        #endregion
2556        #region MorphologyEx
2557#if LANG_JP
2558        /// <summary>
2559        /// 高度なモルフォロジー変換を実行する [iterations=1].
2560        /// 基本の演算として収縮と膨張を(組み合わせて)用いる高度なモルフォロジー変換を行うことができる.
2561        /// </summary>
2562        /// <param name="src">入力画像</param>
2563        /// <param name="dst">出力画像</param>
2564        /// <param name="temp">テンポラリ画像(いくつかの処理で必要とされる)</param>
2565        /// <param name="element">構造要素</param>
2566        /// <param name="operation">モルフォロジー演算の種類</param>
2567#else
2568        /// <summary>
2569        /// Performs advanced morphological transformations using erosion and dilation as basic operations.
2570        /// </summary>
2571        /// <param name="src">Source image. </param>
2572        /// <param name="dst">Destination image. </param>
2573        /// <param name="temp">Temporary image, required in some cases. </param>
2574        /// <param name="element">Structuring element. </param>
2575        /// <param name="operation">Type of morphological operation.</param>
2576#endif
2577        public static void MorphologyEx(CvArr src, CvArr dst, CvArr temp, IplConvKernel element, MorphologyOperation operation)
2578        {
2579            MorphologyEx(src, dst, temp, element, operation);
2580        }
2581#if LANG_JP
2582        /// <summary>
2583        /// 高度なモルフォロジー変換を実行する.
2584        /// 基本の演算として収縮と膨張を(組み合わせて)用いる高度なモルフォロジー変換を行うことができる.
2585        /// </summary>
2586        /// <param name="src">入力画像</param>
2587        /// <param name="dst">出力画像</param>
2588        /// <param name="temp">テンポラリ画像(いくつかの処理で必要とされる)</param>
2589        /// <param name="element">構造要素</param>
2590        /// <param name="operation">モルフォロジー演算の種類</param>
2591        /// <param name="iterations">収縮と膨張の繰り返し回数</param>
2592#else
2593        /// <summary>
2594        /// Performs advanced morphological transformations using erosion and dilation as basic operations.
2595        /// </summary>
2596        /// <param name="src">Source image. </param>
2597        /// <param name="dst">Destination image. </param>
2598        /// <param name="temp">Temporary image, required in some cases. </param>
2599        /// <param name="element">Structuring element. </param>
2600        /// <param name="operation">Type of morphological operation.</param>
2601        /// <param name="iterations">Number of times erosion and dilation are applied. </param>
2602#endif
2603        public static void MorphologyEx(CvArr src, CvArr dst, CvArr temp, IplConvKernel element, MorphologyOperation operation, int iterations)
2604        {
2605            if (src == null)
2606                throw new ArgumentNullException("src");
2607            if (dst == null)
2608                throw new ArgumentNullException("dst");
2609            if (temp == null)
2610                throw new ArgumentNullException("temp");
2611            CvDll.cvMorphologyEx(src.CvPtr, dst.CvPtr, temp.CvPtr, element.CvPtr, operation, iterations);
2612        }
2613        #endregion
2614        #region MoveWindow
2615#if LANG_JP
2616        /// <summary>
2617        /// ウィンドウの位置を変更する
2618        /// </summary>
2619        /// <param name="name">位置を変更するウィンドウの名前</param>
2620        /// <param name="x">左上のコーナーの新しい x 座標</param>
2621        /// <param name="y">左上のコーナーの新しい y 座標</param>
2622#else
2623        /// <summary>
2624        /// Changes position of the window.
2625        /// </summary>
2626        /// <param name="name">Name of the window to be resized. </param>
2627        /// <param name="x">New x coordinate of top-left corner </param>
2628        /// <param name="y">New y coordinate of top-left corner </param>
2629#endif
2630        public static void MoveWindow(string name, int x, int y)
2631        {
2632            CvDll.cvMoveWindow(name, x, y);
2633        }
2634        #endregion
2635        #region mSet
2636        /// <summary>
2637        /// シングルチャンネル浮動小数点型行列の場合における,cvSetReal2Dの高速化版関数である.
2638        /// </summary>
2639        /// <param name="mat">入力行列</param>
2640        /// <param name="row">行の0を基準としたインデックス</param>
2641        /// <param name="col">列の0を基準としたインデックス</param>
2642        /// <param name="value">行列の要素の新しい値</param>
2643        public static void mSet(this CvMat mat, int row, int col, double value)
2644        {
2645            CvInline.cvmSet(mat.CvPtr, row, col, value);
2646        }
2647        #endregion
2648        #region Mul
2649        /// <summary>
2650        /// 二つの配列の要素同士を乗算する (scale=1).
2651        /// dst(I) = scale * src1(I) * src2(I)
2652        /// </summary>
2653        /// <param name="src1">1番目の入力配列</param>
2654        /// <param name="src2">2番目の入力配列</param>
2655        /// <param name="dst">出力配列</param>
2656        public static void Mul(this CvArr src1, CvArr src2, CvArr dst)
2657        {
2658            Mul(src1, src2, dst, 1d);
2659        }
2660        /// <summary>
2661        /// 二つの配列の要素同士を乗算する.
2662        /// dst(I) = scale * src1(I) * src2(I)
2663        /// </summary>
2664        /// <param name="src1">1番目の入力配列</param>
2665        /// <param name="src2">2番目の入力配列</param>
2666        /// <param name="dst">出力配列</param>
2667        /// <param name="scale">任意のスケーリング係数</param>
2668        public static void Mul(this CvArr src1, CvArr src2, CvArr dst, double scale)
2669        {
2670            if (src1 == null)
2671                throw new ArgumentNullException("src1");
2672            if (src2 == null)
2673                throw new ArgumentNullException("src2");
2674            if (dst == null)
2675                throw new ArgumentNullException("dst");
2676            CvDll.cvMul(src1.CvPtr, src2.CvPtr, dst.CvPtr, scale);
2677        }
2678        #endregion
2679        #region MulSpectrums
2680        /// <summary>
2681        /// 二つのフーリエスペクトラムの要素ごとの乗算を行う
2682        /// </summary>
2683        /// <param name="src1">1番目の入力配列</param>
2684        /// <param name="src2">2番目の入力配列</param>
2685        /// <param name="dst">入力配列と同じタイプ・サイズの出力配列</param>
2686        /// <param name="flags">処理フラグ</param>
2687        public static void cvMulSpectrums(CvArr src1, CvArr src2, CvArr dst, MulSpectrumsFlag flags)
2688        {
2689            if (src1 == null)
2690                throw new ArgumentNullException("src1");
2691            if (src2 == null)
2692                throw new ArgumentNullException("src2");
2693            if (dst == null)
2694                throw new ArgumentNullException("dst");
2695            CvDll.cvMulSpectrums(src1.CvPtr, src2.CvPtr, dst.CvPtr, flags);
2696        }
2697        #endregion
2698        #region MultiplyAcc
2699#if LANG_JP
2700        /// <summary>
2701        /// アキュムレータに二つの入力画像の積を加算する
2702        /// </summary>
2703        /// <param name="image1">1番目の入力画像,1 または 3 チャンネル,8 ビットあるいは 32 ビッ ト浮動小数点型.(マルチチャンネル画像の各チャンネルは,個別に処理される).</param>
2704        /// <param name="image2">2番目の入力画像.1番目画像と同様のフォーマット.</param>
2705        /// <param name="acc">入力画像と同じチャンネル数のアキュムレータ,32 ビットあるいは 64 ビット浮動小数点型.</param>
2706#else
2707        /// <summary>
2708        /// Adds product of two input images to accumulator
2709        /// </summary>
2710        /// <param name="image1">First input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently). </param>
2711        /// <param name="image2">Second input image, the same format as the first one. </param>
2712        /// <param name="acc">Accumulator of the same number of channels as input images, 32-bit or 64-bit floating-point. </param>
2713#endif
2714        public static void MultiplyAcc(CvArr image1, CvArr image2, CvArr acc)
2715        {
2716            MultiplyAcc(image1, image2, acc);
2717        }
2718#if LANG_JP
2719        /// <summary>
2720        /// アキュムレータに二つの入力画像の積を加算する
2721        /// </summary>
2722        /// <param name="image1">1番目の入力画像,1 または 3 チャンネル,8 ビットあるいは 32 ビッ ト浮動小数点型.(マルチチャンネル画像の各チャンネルは,個別に処理される).</param>
2723        /// <param name="image2">2番目の入力画像.1番目画像と同様のフォーマット.</param>
2724        /// <param name="acc">入力画像と同じチャンネル数のアキュムレータ,32 ビットあるいは 64 ビット浮動小数点型.</param>
2725        /// <param name="mask">オプションの処理マスク.</param>
2726#else
2727        /// <summary>
2728        /// Adds product of two input images to accumulator
2729        /// </summary>
2730        /// <param name="image1">First input image, 1- or 3-channel, 8-bit or 32-bit floating point (each channel of multi-channel image is processed independently). </param>
2731        /// <param name="image2">Second input image, the same format as the first one. </param>
2732        /// <param name="acc">Accumulator of the same number of channels as input images, 32-bit or 64-bit floating-point. </param>
2733        /// <param name="mask">Optional operation mask. </param>
2734#endif
2735        public static void MultiplyAcc(CvArr image1, CvArr image2, CvArr acc, CvArr mask)
2736        {
2737            if (image1 == null)
2738                throw new ArgumentNullException("image1");
2739            if (image2 == null)
2740                throw new ArgumentNullException("image2");
2741            if (acc == null)
2742                throw new ArgumentNullException("acc");
2743            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
2744            CvDll.cvMultiplyAcc(image1.CvPtr, image2.CvPtr, acc.CvPtr, maskPtr);
2745        }
2746        #endregion
2747        #region MulTransposed
2748        /// <summary>
2749        /// 行列と転置行列の乗算を行う
2750        /// </summary>
2751        /// <param name="src">入力行列</param>
2752        /// <param name="dst">出力行列</param>
2753        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param>
2754        public static void MulTransposed(CvArr src, CvArr dst, bool order)
2755        {
2756            MulTransposed(src, dst, order, null);
2757        }
2758        /// <summary>
2759        /// 行列と転置行列の乗算を行う
2760        /// </summary>
2761        /// <param name="src">入力行列</param>
2762        /// <param name="dst">出力行列</param>
2763        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param>
2764        /// <param name="delta">オプション配列,乗算する前にsrcから引かれる.</param>
2765        public static void MulTransposed(CvArr src, CvArr dst, bool order, CvArr delta)
2766        {
2767            MulTransposed(src, dst, order, null);
2768        }
2769        /// <summary>
2770        /// 行列と転置行列の乗算を行う
2771        /// </summary>
2772        /// <param name="src">入力行列</param>
2773        /// <param name="dst">出力行列</param>
2774        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param>
2775        /// <param name="delta">オプション配列,乗算する前にsrcから引かれる.</param>
2776        /// <param name="scale"></param>
2777        public static void MulTransposed(CvArr src, CvArr dst, bool order, CvArr delta, double scale)
2778        {
2779            if (src == null)
2780                throw new ArgumentNullException("src");
2781            if (dst == null)
2782                throw new ArgumentNullException("dst");
2783            IntPtr deltaPtr = (delta == null) ? IntPtr.Zero : delta.CvPtr;
2784            CvDll.cvMulTransposed(src.CvPtr, dst.CvPtr, order, deltaPtr, scale);
2785        }
2786        #endregion
2787        #region NamedWindow
2788#if LANG_JP
2789        /// <summary>
2790        /// 画像とトラックバーのプレースホルダとして利用されるウィンドウを作成する.
2791        /// このウィンドウは,その名前によって参照される.
2792        /// </summary>
2793        /// <param name="name">ウィンドウの識別に用いられるウィンドウ名で,ウィンドウのタイトルバ ーに表示される.</param>
2794        /// <returns></returns>
2795#else
2796        /// <summary>
2797        /// Creates a window which can be used as a placeholder for images and trackbars. Created windows are reffered by their names.
2798        /// </summary>
2799        /// <param name="name">Name of the window which is used as window identifier and appears in the window caption. </param>
2800        /// <returns></returns>
2801#endif
2802        public static int NamedWindow(string name)
2803        {
2804            return CvDll.cvNamedWindow(name, WindowMode.AutoSize);
2805        }
2806#if LANG_JP
2807        /// <summary>
2808        /// 画像とトラックバーのプレースホルダとして利用されるウィンドウを作成する.
2809        /// このウィンドウは,その名前によって参照される.
2810        /// </summary>
2811        /// <param name="name">ウィンドウの識別に用いられるウィンドウ名で,ウィンドウのタイトルバ ーに表示される</param>
2812        /// <param name="flags">ウィンドウのフラグ</param>
2813        /// <returns></returns>
2814#else
2815        /// <summary>
2816        /// Creates a window which can be used as a placeholder for images and trackbars. Created windows are reffered by their names.
2817        /// </summary>
2818        /// <param name="name">Name of the window which is used as window identifier and appears in the window caption. </param>
2819        /// <param name="flags">Flags of the window. Currently the only supported flag is WindowMode.AutoSize.
2820        /// If it is set, window size is automatically adjusted to fit the displayed image (see cvShowImage), while user can not change the window size manually. </param>
2821        /// <returns></returns>
2822#endif
2823        public static int NamedWindow(string name, WindowMode flags)
2824        {
2825            return CvDll.cvNamedWindow(name, flags);
2826        }
2827        #endregion
2828        #region NextGraphItem
2829#if LANG_JP
2830        /// <summary>
2831        ///
2832        /// </summary>
2833        /// <param name="scanner"></param>
2834        /// <returns></returns>
2835#else
2836        /// <summary>
2837        /// Returns index of graph vertex
2838        /// </summary>
2839        /// <param name="scanner">Graph traversal state. It is updated by the function. </param>
2840        /// <returns>The function cvNextGraphItem traverses through the graph until an event interesting to the user (that is, an event, specified in the mask in cvCreateGraphScanner call) is met or the traversal is over. In the first case it returns one of the events, listed in the description of mask parameter above and with the next call it resumes the traversal. In the latter case it returns CV_GRAPH_OVER (-1). When the event is CV_GRAPH_VERTEX, or CV_GRAPH_BACKTRACKING or CV_GRAPH_NEW_TREE, the currently observed vertex is stored in scanner->vtx. And if the event is edge-related, the edge itself is stored at scanner->edge, the previously visited vertex - at scanner->vtx and the other ending vertex of the edge - at scanner->dst.</returns>
2841#endif
2842        public static int NextGraphItem(this CvGraphScanner scanner)
2843        {
2844            if (scanner == null)
2845            {
2846                throw new ArgumentNullException("scanner");
2847            }
2848
2849            return CvDll.cvNextGraphItem(scanner.CvPtr);
2850        }
2851        #endregion
2852        #region NextLinePoint
2853#if LANG_JP
2854        /// <summary>
2855        ///
2856        /// </summary>
2857        /// <param name="line_iterator"></param>
2858        /// <returns></returns>
2859#else
2860        /// <summary>
2861        /// Moves iterator to the next line point
2862        /// </summary>
2863        /// <param name="line_iterator">LineIterator object </param>
2864        /// <returns></returns>
2865#endif
2866        public static void NextLinePoint(CvLineIterator line_iterator)
2867        {
2868            line_iterator.NextLinePoint();
2869        }
2870        #endregion
2871        #region NextTreeNode
2872#if LANG_JP
2873        /// <summary>
2874        /// 現在のノードを返し,イテレータを次のノードに移動させる.
2875        /// </summary>
2876        /// <param name="tree_iterator">初期化されるツリーのイテレータ</param>
2877        /// <returns></returns>
2878#else
2879        /// <summary>
2880        ///
2881        /// </summary>
2882        /// <param name="tree_iterator"></param>
2883        /// <returns></returns>
2884#endif
2885        public static IntPtr NextTreeNode(this CvTreeNodeIterator tree_iterator)
2886        {
2887            if (tree_iterator == null)
2888            {
2889                throw new ArgumentNullException("tree_iterator");
2890            }
2891            return CvDll.cvNextTreeNode(tree_iterator);
2892        }
2893        /// <summary>
2894        ///
2895        /// </summary>
2896        /// <typeparam name="T"></typeparam>
2897        /// <param name="tree_iterator"></param>
2898        /// <returns></returns>
2899        public static T NextTreeNode<T>(this CvTreeNodeIterator tree_iterator) where T : CvArr
2900        {
2901            if (tree_iterator == null)
2902            {
2903                throw new ArgumentNullException("tree_iterator");
2904            }
2905            IntPtr result = CvDll.cvNextTreeNode(tree_iterator);
2906            if (result == IntPtr.Zero)
2907            {
2908                return null;
2909            }
2910            else
2911            {
2912                return Cast<T>(result);
2913            }
2914        }
2915        /// <summary>
2916        ///
2917        /// </summary>
2918        /// <typeparam name="T"></typeparam>
2919        /// <param name="tree_iterator"></param>
2920        /// <returns></returns>
2921        public static T NextTreeNode<T>(this CvTreeNodeIterator<T> tree_iterator) where T : CvArr
2922        {
2923            return NextTreeNode<T>((CvTreeNodeIterator)tree_iterator);
2924        }
2925        #endregion
2926        #region Norm
2927        /// <summary>
2928        /// 配列の絶対値ノルム(absolute array norm)を計算する
2929        /// </summary>
2930        /// <param name="arr1">1番目の入力画像</param>
2931        public static void Norm(this CvArr arr1)
2932        {
2933            Norm(arr1, null, NormType.L2, null);
2934        }
2935        /// <summary>
2936        /// 配列の絶対値ノルム(absolute array norm),絶対値差分ノルム(absolute difference norm),相対値差分ノルム(relative difference norm)を計算する
2937        /// </summary>
2938        /// <param name="arr1">1番目の入力画像</param>
2939        /// <param name="arr2">2番目の入力画像.null の場合,arr1の絶対値ノルムが計算され,そうでない場合は,arr1-arr2 の絶対値あるいは相対値ノルムが計算される. </param>
2940        public static void Norm(CvArr arr1, CvArr arr2)
2941        {
2942            Norm(arr1, arr2, NormType.L2, null);
2943        }
2944        /// <summary>
2945        /// 配列の絶対値ノルム(absolute array norm),絶対値差分ノルム(absolute difference norm),相対値差分ノルム(relative difference norm)を計算する
2946        /// </summary>
2947        /// <param name="arr1">1番目の入力画像</param>
2948        /// <param name="arr2">2番目の入力画像.null の場合,arr1の絶対値ノルムが計算され,そうでない場合は,arr1-arr2 の絶対値あるいは相対値ノルムが計算される. </param>
2949        /// <param name="norm_type">ノルムのタイプ (リファレンス参照)</param>
2950        public static void Norm(CvArr arr1, CvArr arr2, NormType norm_type)
2951        {
2952            Norm(arr1, arr2, norm_type, null);
2953        }
2954        /// <summary>
2955        /// 配列の絶対値ノルム(absolute array norm),絶対値差分ノルム(absolute difference norm),相対値差分ノルム(relative difference norm)を計算する
2956        /// </summary>
2957        /// <param name="arr1">1番目の入力画像</param>
2958        /// <param name="arr2">2番目の入力画像.null の場合,arr1の絶対値ノルムが計算され,そうでない場合は,arr1-arr2 の絶対値あるいは相対値ノルムが計算される. </param>
2959        /// <param name="norm_type">ノルムのタイプ (リファレンス参照)</param>
2960        /// <param name="mask">オプションの処理マスク</param>
2961        public static void Norm(CvArr arr1, CvArr arr2, NormType norm_type, CvArr mask)
2962        {
2963            if (arr1 == null)
2964            {
2965                throw new ArgumentNullException("arr1");
2966            }
2967            IntPtr arr2Ptr = (arr2 == null) ? IntPtr.Zero : arr2.CvPtr;
2968            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
2969            CvDll.cvNorm(arr1.CvPtr, arr2.CvPtr, norm_type, maskPtr);
2970        }
2971        #endregion
2972        #region Normalize
2973        /// <summary>
2974        /// 指定のノルムになるように,あるいは値が指定の範囲になるように,配列を正規化する
2975        /// </summary>
2976        /// <param name="src">入力配列</param>
2977        /// <param name="dst">出力配列.インプレース処理が可能.</param>
2978        public static void Normalize(this CvArr src, CvArr dst)
2979        {
2980            Normalize(src, dst, 1, 0, NormType.L2, null);
2981        }
2982        /// <summary>
2983        /// 指定のノルムになるように,あるいは値が指定の範囲になるように,配列を正規化する
2984        /// </summary>
2985        /// <param name="src">入力配列</param>
2986        /// <param name="dst">出力配列.インプレース処理が可能.</param>
2987        /// <param name="a">出力配列の最小値または最大値,あるいは出力配列のノルム.</param>
2988        /// <param name="b">出力配列の最大値または最小値.</param>
2989        public static void Normalize(this CvArr src, CvArr dst, double a, double b)
2990        {
2991            Normalize(src, dst, a, b, NormType.L2, null);
2992        }
2993        /// <summary>
2994        /// 指定のノルムになるように,あるいは値が指定の範囲になるように,配列を正規化する
2995        /// </summary>
2996        /// <param name="src">入力配列</param>
2997        /// <param name="dst">出力配列.インプレース処理が可能.</param>
2998        /// <param name="a">出力配列の最小値または最大値,あるいは出力配列のノルム.</param>
2999        /// <param name="b">出力配列の最大値または最小値.</param>
3000        /// <param name="norm_type">正規化のタイプ. C, L1, L2, MinMaxのうち1つ.</param>
3001        public static void Normalize(this CvArr src, CvArr dst, double a, double b, NormType norm_type)
3002        {
3003            Normalize(src, dst, a, b, norm_type, null);
3004        }
3005        /// <summary>
3006        /// 指定のノルムになるように,あるいは値が指定の範囲になるように,配列を正規化する
3007        /// </summary>
3008        /// <param name="src">入力配列</param>
3009        /// <param name="dst">出力配列.インプレース処理が可能.</param>
3010        /// <param name="a">出力配列の最小値または最大値,あるいは出力配列のノルム.</param>
3011        /// <param name="b">出力配列の最大値または最小値.</param>
3012        /// <param name="norm_type">正規化のタイプ. C, L1, L2, MinMaxのうち1つ.</param>
3013        /// <param name="mask">操作マスク.特定の配列要素のみを正規化するためのマスク.</param>
3014        public static void Normalize(this CvArr src, CvArr dst, double a, double b, NormType norm_type, CvArr mask)
3015        {
3016            if (src == null)
3017                throw new ArgumentNullException("src");
3018            if (dst == null)
3019                throw new ArgumentNullException("dst");
3020            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
3021            CvDll.cvNormalize(src.CvPtr, dst.CvPtr, a, b, norm_type, maskPtr);
3022        }
3023        #endregion
3024        #region NormalizeHist
3025#if LANG_JP
3026        /// <summary>
3027        /// ヒストグラムの正規化を行う.
3028        /// ビンの値の合計が factor に等しくなるようにスケーリングする事で,ヒストグラムのビンを正規化する.
3029        /// </summary>
3030        /// <param name="hist">ヒストグラムへの参照</param>
3031        /// <param name="factor">正規化係数</param>
3032#else
3033        /// <summary>
3034        /// Normalizes the histogram bins by scaling them, such that the sum of the bins becomes equal to factor.
3035        /// </summary>
3036        /// <param name="hist">Reference to the histogram. </param>
3037        /// <param name="factor">Threshold level. </param>
3038#endif
3039        public static void NormalizeHist(CvHistogram hist, double factor)
3040        {
3041            if (hist == null)
3042            {
3043                throw new ArgumentNullException("hist");
3044            }
3045            CvDll.cvNormalizeHist(hist.CvPtr, factor);
3046        }
3047        #endregion
3048        #region Not
3049        /// <summary>
3050        /// 各配列要素のビット単位の反転を行う
3051        /// </summary>
3052        /// <param name="src">入力配列</param>
3053        /// <param name="dst">出力配列</param>
3054        public static void Not(this CvArr src, CvArr dst)
3055        {
3056            if (src == null)
3057                throw new ArgumentNullException("src");
3058            if (dst == null)
3059                throw new ArgumentNullException("dst");
3060            CvDll.cvNot(src.CvPtr, dst.CvPtr);
3061        }
3062        #endregion
3063        #region OpenFileStorage
3064        /// <summary>
3065        /// データの読み書きのためのファイルを開く.
3066        /// 書き込みの場合は,新しいファイルが作成されるか,ファイルが存在する場合には上書きされる.
3067        /// また,読み書きされるファイルの種類は拡張子で判別される. XMLの場合は.xml,YAMLの場合は.ymlまたは.yamlである.
3068        /// </summary>
3069        /// <param name="filename">ストレージに関連づけられたファイルの名前</param>
3070        /// <param name="memstorage">一時的なデータや,CvSeqや CvGraphなどの動的構造体の保存に使われるメモリストレージ.nullの場合,一時的なメモリが確保されて使用される.</param>
3071        /// <param name="flags">ファイルを開く方法または作成する方法</param>
3072        /// <returns>開いたファイルと関連付けられたCvFileStorageクラスへの参照</returns>
3073        public static CvFileStorage OpenFileStorage(string filename, CvMemStorage memstorage, FileStorageMode flags)
3074        {
3075            return new CvFileStorage(filename, memstorage, flags);
3076        }
3077        #endregion
3078        #region Or
3079        /// <summary>
3080        /// 二つの配列の要素ごとの論理和(OR)を計算する.
3081        /// dst(I)=src1(I)|src2(I)
3082        /// </summary>
3083        /// <param name="src1">1番目の入力配列</param>
3084        /// <param name="src2">2番目の入力配列</param>
3085        /// <param name="dst">出力配列</param>
3086        public static void Or(this CvArr src1, CvArr src2, CvArr dst)
3087        {
3088            Or(src1, src2, dst, null);
3089        }
3090        /// <summary>
3091        /// 二つの配列の要素ごとの論理和(OR)を計算する.
3092        /// dst(I)=src1(I)|src2(I) [mask(I)!=0の場合]
3093        /// </summary>
3094        /// <param name="src1">1番目の入力配列</param>
3095        /// <param name="src2">2番目の入力配列</param>
3096        /// <param name="dst">出力配列</param>
3097        /// <param name="mask">処理マスク.8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する). </param>
3098        public static void Or(this CvArr src1, CvArr src2, CvArr dst, CvArr mask)
3099        {
3100            if (src1 == null)
3101                throw new ArgumentNullException("src1");
3102            if (src2 == null)
3103                throw new ArgumentNullException("src2");
3104            if (dst == null)
3105                throw new ArgumentNullException("dst");
3106            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
3107            CvDll.cvOr(src1.CvPtr, src2.CvPtr, dst.CvPtr, maskPtr);
3108        }
3109        #endregion
3110        #region OrS
3111        /// <summary>
3112        /// 配列の各要素とスカラーとのビット単位の論理和(OR)を計算する.
3113        /// 実際の計算の前に,スカラーは配列と同じタイプに変換される.浮動小数点型配列の場合,それらのビット表現が処理に使われる.
3114        /// すべての配列(マスクを除く)は同じタイプで,配列のサイズ(またはROIのサイズ)も同じでなければならない.
3115        /// dst(I)=src(I)|value
3116        /// </summary>
3117        /// <param name="src1">入力配列</param>
3118        /// <param name="value">処理に用いるスカラー</param>
3119        /// <param name="dst">出力配列</param>
3120        public static void OrS(this CvArr src1, CvScalar value, CvArr dst)
3121        {
3122            OrS(src1, value, dst);
3123        }
3124        /// <summary>
3125        /// 配列の各要素とスカラーとのビット単位の論理和(OR)を計算する.
3126        /// 実際の計算の前に,スカラーは配列と同じタイプに変換される.浮動小数点型配列の場合,それらのビット表現が処理に使われる.
3127        /// すべての配列(マスクを除く)は同じタイプで,配列のサイズ(またはROIのサイズ)も同じでなければならない.
3128        /// dst(I)=src(I)|value [mask(I)!=0の場合]
3129        /// </summary>
3130        /// <param name="src1">入力配列</param>
3131        /// <param name="value">処理に用いるスカラー</param>
3132        /// <param name="dst">出力配列</param>
3133        /// <param name="mask">処理マスク.8ビットシングルチャンネル配列(出力配列のどの要素が変更されるかを指定する).</param>
3134        public static void OrS(this CvArr src1, CvScalar value, CvArr dst, CvArr mask)
3135        {
3136            if (src1 == null)
3137                throw new ArgumentNullException("src1");
3138            if (dst == null)
3139                throw new ArgumentNullException("dst");
3140            IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
3141            CvDll.cvOrS(src1.CvPtr, value, dst.CvPtr, maskPtr);
3142        }
3143        #endregion
3144        #region PerspectiveTransform
3145        /// <summary>
3146        /// ベクトルの透視投影変換を行う
3147        /// </summary>
3148        /// <param name="src">3チャンネルの浮動小数点型入力配列</param>
3149        /// <param name="dst">3チャンネルの浮動小数点型出力配列</param>
3150        /// <param name="mat">3×3 または 4×4 の変換行列</param>
3151        public static void PerspectiveTransform(this CvArr src, CvArr dst, CvMat mat)
3152        {
3153            if (src == null)
3154                throw new ArgumentNullException("img");
3155            if (dst == null)
3156                throw new ArgumentNullException("pts");
3157            if (mat == null)
3158                throw new ArgumentNullException("pts");
3159            CvDll.cvPerspectiveTransform(src.CvPtr, dst.CvPtr, mat.CvPtr);
3160        }
3161        #endregion
3162        #region Point
3163        /// <summary>
3164        /// 整数座標系による2次元の点を生成する (cvPoint相当)
3165        /// </summary>
3166        /// <param name="x"></param>
3167        /// <param name="y"></param>
3168        /// <returns></returns>
3169        public static CvPoint Point(int x, int y)
3170        {
3171            return new CvPoint(x, y);
3172        }
3173        #endregion
3174        #region Point2D32f
3175        /// <summary>
3176        /// 浮動小数点型(単精度)座標系による2次元の点を生成する (cvPoint2D32f相当)
3177        /// </summary>
3178        /// <param name="x"></param>
3179        /// <param name="y"></param>
3180        /// <returns></returns>
3181        public static CvPoint2D32f Point2D32f(float x, float y)
3182        {
3183            return new CvPoint2D32f(x, y);
3184        }
3185        #endregion
3186        #region Point2D64f
3187        /// <summary>
3188        /// 浮動小数点型(倍精度)座標系による2次元の点を生成する (cvPoint2D32f相当)
3189        /// </summary>
3190        /// <param name="x"></param>
3191        /// <param name="y"></param>
3192        /// <returns></returns>
3193        public static CvPoint2D64f Point2D64f(double x, double y)
3194        {
3195            return new CvPoint2D64f(x, y);
3196        }
3197        #endregion
3198        #region Point3D32f
3199        /// <summary>
3200        /// 浮動小数点型(単精度)座標系による3次元の点を生成する (cvPoint3D32f相当)
3201        /// </summary>
3202        /// <param name="x"></param>
3203        /// <param name="y"></param>
3204        /// <param name="z"></param>
3205        /// <returns></returns>
3206        public static CvPoint3D32f Point3D32f(float x, float y, float z)
3207        {
3208            return new CvPoint3D32f(x, y, z);
3209        }
3210        #endregion
3211        #region Point3D64f
3212        /// <summary>
3213        /// 浮動小数点型(倍精度)座標系による3次元の点を生成する (cvPoint3D64f相当)
3214        /// </summary>
3215        /// <param name="x"></param>
3216        /// <param name="y"></param>
3217        /// <param name="z"></param>
3218        /// <returns></returns>
3219        public static CvPoint3D64f Point3D64f(double x, double y, double z)
3220        {
3221            return new CvPoint3D64f(x, y, z);
3222        }
3223        #endregion
3224        #region PointPolygonTest
3225#if LANG_JP
3226        /// <summary>
3227        /// 点と輪郭の関係を調べる
3228        /// </summary>
3229        /// <param name="contour">入力輪郭</param>
3230        /// <param name="pt">入力輪郭に対して調べる点</param>
3231        /// <param name="measure_dist">非0の場合, この関数は与えた点に最も近い輪郭までの距離を求める.</param>
3232        /// <returns>点が輪郭の内側にあるか,外側にあるか,輪郭上に乗っている(あるいは,頂点と一致している)かを判別し,それぞれの場合に応じて正か負か0を返す.
3233        /// measure_dist=0の場合,戻り値はそれぞれ+1,-1,0である. measure_dist≠0の場合,点と最近傍輪郭までの符号付きの距離を返す.</returns>
3234#else
3235        /// <summary>
3236        /// Point in contour test
3237        /// </summary>
3238        /// <param name="contour">Input contour.</param>
3239        /// <param name="pt">The point tested against the contour.</param>
3240        /// <param name="measure_dist">If it is true, the function estimates distance from the point to the nearest contour edge.</param>
3241        /// <returns>The function cvPointPolygonTest determines whether the point is inside contour, outside, or lies on an edge (or coinsides with a vertex). It returns positive, negative or zero value, correspondingly. When measure_dist=0, the return value is +1, -1 and 0, respectively. When measure_dist≠0, it is a signed distance between the point and the nearest contour edge.</returns>
3242#endif
3243        public static double PointPolygonTest(this CvArr contour, CvPoint2D32f pt, bool measure_dist)
3244        {
3245            if (contour == null)
3246                throw new ArgumentNullException("contour");
3247            return CvDll.cvPointPolygonTest(contour.CvPtr, pt, System.Convert.ToInt32(measure_dist));
3248        }
3249        #endregion
3250        #region PointSeqFromMat
3251#if LANG_JP
3252        /// <summary>
3253        /// 点のベクトルを用いて,点のシーケンスヘッダを初期化する
3254        /// </summary>
3255        /// <param name="seq_kind">点のシーケンスの種類</param>
3256        /// <param name="mat">入力行列.点の連続的な1次元ベクトルで,CV_32SC2型かCV_32FC2型でなければならない.</param>
3257        /// <param name="contour_header">輪郭ヘッダ.この関数で初期化される.</param>
3258        /// <param name="block">シーケンスブロックヘッダ.この関数で初期化される.</param>
3259#else
3260        /// <summary>
3261        /// Initializes point sequence header from a point vector
3262        /// </summary>
3263        /// <param name="seq_kind">Type of the point sequence.</param>
3264        /// <param name="mat">Input matrix. It should be continuous 1-dimensional vector of points, that is, it should have type CV_32SC2 or CV_32FC2.</param>
3265        /// <param name="contour_header">Contour header, initialized by the function. </param>
3266        /// <param name="block">Sequence block header, initialized by the function. </param>
3267#endif
3268        public static CvSeq PointSeqFromMat(SeqType seq_kind, CvArr mat, out CvContour contour_header, out CvSeqBlock block)
3269        {
3270            if (mat == null)
3271                throw new ArgumentNullException("mat");
3272            if (mat.ElemType != MatrixType.F32C2 && mat.ElemType != MatrixType.S32C2)
3273                throw new ArgumentException("mat should have type S32C2 or F32C2.");
3274
3275            contour_header = new CvContour();
3276            block = new CvSeqBlock();
3277            IntPtr result = CvDll.cvPointSeqFromMat(seq_kind, mat.CvPtr, contour_header.CvPtr, block.CvPtr);
3278            if (result == IntPtr.Zero)
3279                return null;
3280            else
3281                return new CvSeq(result);
3282        }
3283        #endregion
3284        #region PolarToCart
3285#if LANG_JP
3286        /// <summary>
3287        ///
3288        /// </summary>
3289        /// <param name="magnitude"></param>
3290        /// <param name="angle"></param>
3291        /// <param name="x"></param>
3292        /// <param name="y"></param>
3293        /// <returns></returns>
3294#else
3295        /// <summary>
3296        /// Calculates cartesian coordinates of 2d vectors represented in polar form
3297        /// </summary>
3298        /// <param name="magnitude">The array of magnitudes. If it is NULL, the magnitudes are assumed all 1’s. </param>
3299        /// <param name="angle">The array of angles, whether in radians or degrees. </param>
3300        /// <param name="x">The destination array of x-coordinates, may be set to NULL if it is not needed. </param>
3301        /// <param name="y">The destination array of y-coordinates, mau be set to NULL if it is not needed. </param>
3302        /// <returns></returns>
3303#endif
3304        public static void PolarToCart(CvArr magnitude, CvArr angle, CvArr x, CvArr y)
3305        {
3306            PolarToCart(magnitude, angle, x, y, AngleUnit.Radians);
3307        }
3308#if LANG_JP
3309        /// <summary>
3310        ///
3311        /// </summary>
3312        /// <param name="x"></param>
3313        /// <param name="y"></param>
3314        /// <param name="magnitude"></param>
3315        /// <param name="angle"></param>
3316        /// <param name="unit"></param>
3317        /// <returns></returns>
3318#else
3319        /// <summary>
3320        /// Calculates cartesian coordinates of 2d vectors represented in polar form
3321        /// </summary>
3322        /// <param name="magnitude">The array of magnitudes. If it is NULL, the magnitudes are assumed all 1’s. </param>
3323        /// <param name="angle">The array of angles, whether in radians or degrees. </param>
3324        /// <param name="x">The destination array of x-coordinates, may be set to NULL if it is not needed. </param>
3325        /// <param name="y">The destination array of y-coordinates, mau be set to NULL if it is not needed. </param>
3326        /// <param name="unit">The flag indicating whether the angles are measured in radians, which is default mode, or in degrees. </param>
3327        /// <returns></returns>
3328#endif
3329        public static void PolarToCart(CvArr magnitude, CvArr angle, CvArr x, CvArr y, AngleUnit unit)
3330        {
3331            if (angle == null)
3332            {
3333                throw new ArgumentNullException("angle");
3334            }
3335            IntPtr magnitude_ptr = (magnitude == null) ? IntPtr.Zero : magnitude.CvPtr;
3336            IntPtr x_ptr = (x == null) ? IntPtr.Zero : x.CvPtr;
3337            IntPtr y_ptr = (y == null) ? IntPtr.Zero : y.CvPtr;
3338            CvDll.cvPolarToCart(magnitude_ptr, angle.CvPtr, x.CvPtr, y.CvPtr, unit);
3339        }
3340        #endregion
3341        #region PolyLine
3342        /// <summary>
3343        /// 一つ,もしくは複数のポリラインを描画する
3344        /// </summary>
3345        /// <param name="img">ポリラインが描かれる画像</param>
3346        /// <param name="pts">ポリラインの配列の配列</param>
3347        /// <param name="is_closed">ポリラインを閉じるかどうかを指定する.閉じる場合,それぞれの領域の最後の頂点と最初の頂点を結ぶ線分を描画する. </param>
3348        /// <param name="color">線の色</param>
3349        public static void PolyLine(this CvArr img, CvPoint[][] pts, bool is_closed, CvColor color)
3350        {
3351            PolyLine(img, pts, is_closed, color, 1, LineType.Link8, 0);
3352        }
3353        /// <summary>
3354        /// 一つ,もしくは複数のポリラインを描画する
3355        /// </summary>
3356        /// <param name="img">ポリラインが描かれる画像</param>
3357        /// <param name="pts">ポリラインの配列の配列</param>
3358        /// <param name="is_closed">ポリラインを閉じるかどうかを指定する.閉じる場合,それぞれの領域の最後の頂点と最初の頂点を結ぶ線分を描画する. </param>
3359        /// <param name="color">線の色</param>
3360        /// <param name="thickness">線の太さ</param>
3361        public static void PolyLine(this CvArr img, CvPoint[][] pts, bool is_closed, CvColor color, int thickness)
3362        {
3363            PolyLine(img, pts, is_closed, color, thickness, LineType.Link8, 0);
3364        }
3365        /// <summary>
3366        /// 一つ,もしくは複数のポリラインを描画する
3367        /// </summary>
3368        /// <param name="img">ポリラインが描かれる画像</param>
3369        /// <param name="pts">ポリラインの配列の配列</param>
3370        /// <param name="is_closed">ポリラインを閉じるかどうかを指定する.閉じる場合,それぞれの領域の最後の頂点と最初の頂点を結ぶ線分を描画する. </param>
3371        /// <param name="color">線の色</param>
3372        /// <param name="thickness">線の太さ</param>
3373        /// <param name="line_type">線の種類</param>
3374        public static void PolyLine(this CvArr img, CvPoint[][] pts, bool is_closed, CvColor color, int thickness, LineType line_type)
3375        {
3376            PolyLine(img, pts, is_closed, color, thickness, line_type, 0);
3377        }
3378        /// <summary>
3379        /// 一つ,もしくは複数のポリラインを描画する
3380        /// </summary>
3381        /// <param name="img">ポリラインが描かれる画像</param>
3382        /// <param name="pts">ポリラインの配列の配列</param>
3383        /// <param name="is_closed">ポリラインを閉じるかどうかを指定する.閉じる場合,それぞれの領域の最後の頂点と最初の頂点を結ぶ線分を描画する. </param>
3384        /// <param name="color">線の色</param>
3385        /// <param name="thickness">線の太さ</param>
3386        /// <param name="line_type">線の種類</param>
3387        /// <param name="shift">頂点座標の小数点以下の桁を表すビット数</param>
3388        public static void PolyLine(this CvArr img, CvPoint[][] pts, bool is_closed, CvColor color, int thickness, LineType line_type, int shift)
3389        {
3390            if (img == null)
3391                throw new ArgumentNullException("img");
3392            if (pts == null)
3393                throw new ArgumentNullException("pts");
3394
3395            // pts(CvPoint[][])をIntPtr[]に変換する
3396            using (var rangesPtr = new ArrayAddress2<CvPoint>(pts))
3397            {
3398                // nptsの用意
3399                int[] npts = new int[pts.Length];
3400                for (int i = 0; i < pts.Length; i++)
3401                {
3402                    npts[i] = pts[i].Length;
3403                }
3404                // 関数呼び出し
3405                CvDll.cvPolyLine(img.CvPtr, rangesPtr.Pointer, npts, pts.Length, is_closed, color, thickness, line_type, shift);
3406            }
3407        }
3408        #endregion
3409        #region POSIT
3410#if LANG_JP
3411        /// <summary>
3412        /// POSITアルゴリズムの実装
3413        /// </summary>
3414        /// <param name="posit_object">オブジェクト構造体</param>
3415        /// <param name="image_points">オブジェクト上の点を二次元画像平面上へ投影して得られる点群</param>
3416        /// <param name="focal_length">使用するカメラの焦点距離</param>
3417        /// <param name="criteria">反復POSITアルゴリズムの終了条件</param>
3418        /// <param name="rotation_matrix">回転行列</param>
3419        /// <param name="translation_vector">並進ベクトル</param>
3420#else
3421        /// <summary>
3422        /// Implements POSIT algorithm
3423        /// </summary>
3424        /// <param name="posit_object">Posit object structure.</param>
3425        /// <param name="image_points">Object points projections on the 2D image plane.</param>
3426        /// <param name="focal_length">Focal length of the camera used.</param>
3427        /// <param name="criteria">Termination criteria of the iterative POSIT algorithm.</param>
3428        /// <param name="rotation_matrix">Matrix of rotations.</param>
3429        /// <param name="translation_vector">Translation vector.</param>
3430#endif
3431        public static void POSIT(this CvPOSITObject posit_object, CvPoint2D32f[] image_points, double focal_length,
3432              CvTermCriteria criteria, out float[,] rotation_matrix, out float[] translation_vector)
3433        {
3434            if (posit_object == null)
3435                throw new ArgumentNullException("posit_object");
3436            rotation_matrix = new float[3, 3];
3437            translation_vector = new float[3];
3438            CvDll.cvPOSIT(posit_object.CvPtr, ref image_points, focal_length, criteria, rotation_matrix, translation_vector);
3439        }
3440        #endregion
3441        #region Pow
3442        /// <summary>
3443        /// すべての配列要素を累乗する.
3444        /// </summary>
3445        /// <param name="src">入力配列</param>
3446        /// <param name="dst">出力配列.入力と同じタイプでなければならない.</param>
3447        /// <param name="power">累乗の指数</param>
3448        public static void Pow(this CvArr src, CvArr dst, double power)
3449        {
3450            if (src == null)
3451                throw new ArgumentNullException("src");
3452            if (dst == null)
3453                throw new ArgumentNullException("dst");
3454            CvDll.cvPow(src.CvPtr, dst.CvPtr, power);
3455        }
3456        #endregion
3457        #region PreCornerDetect
3458#if LANG_JP
3459        /// <summary>
3460        /// コーナー検出のために,画像ブロックの最小固有値を計算する.
3461        /// すべてのピクセルについて,隣接ブロックにおける導関数の共変動行列の最小固有値だけを求める関数である.
3462        /// </summary>
3463        /// <param name="image">入力画像</param>
3464        /// <param name="corners">コーナーの候補を保存する画像</param>
3465#else
3466        /// <summary>
3467        /// Calculates feature map for corner detection
3468        /// </summary>
3469        /// <param name="image">Input image. </param>
3470        /// <param name="corners">Image to store the corner candidates. </param>
3471#endif
3472        public static void PreCornerDetect(this CvArr image, CvArr corners)
3473        {
3474            PreCornerDetect(image, corners, 0);
3475        }
3476#if LANG_JP
3477        /// <summary>
3478        /// コーナー検出のために,画像ブロックの最小固有値を計算する.
3479        /// すべてのピクセルについて,隣接ブロックにおける導関数の共変動行列の最小固有値だけを求める関数である.
3480        /// </summary>
3481        /// <param name="image">入力画像</param>
3482        /// <param name="corners">コーナーの候補を保存する画像</param>
3483        /// <param name="aperture_size">Sobel演算子のアパーチャサイズ(cvSobel参照).</param>
3484#else
3485        /// <summary>
3486        /// Calculates feature map for corner detection
3487        /// </summary>
3488        /// <param name="image">Input image. </param>
3489        /// <param name="corners">Image to store the corner candidates. </param>
3490        /// <param name="aperture_size">Aperture parameter for Sobel operator.</param>
3491#endif
3492        public static void PreCornerDetect(this CvArr image, CvArr corners, ApertureSize aperture_size)
3493        {
3494            if (image == null)
3495                throw new ArgumentNullException("image");
3496            if (corners == null)
3497                throw new ArgumentNullException("corners");
3498            CvDll.cvPreCornerDetect(image.CvPtr, corners.CvPtr, aperture_size);
3499        }
3500        #endregion
3501        #region PrevTreeNode
3502#if LANG_JP
3503        /// <summary>
3504        /// 現在のノードを返し,イテレータを前のノードに移動させる.
3505        /// </summary>
3506        /// <param name="tree_iterator">初期化されるツリーのイテレータ</param>
3507        /// <returns></returns>
3508#else
3509        /// <summary>
3510        ///
3511        /// </summary>
3512        /// <param name="tree_iterator"></param>
3513        /// <returns></returns>
3514#endif
3515        public static IntPtr PrevTreeNode(this CvTreeNodeIterator tree_iterator)
3516        {
3517            if (tree_iterator == null)
3518            {
3519                throw new ArgumentNullException("tree_iterator");
3520            }
3521            return CvDll.cvPrevTreeNode(tree_iterator);
3522        }
3523        /// <summary>
3524        ///
3525        /// </summary>
3526        /// <typeparam name="T"></typeparam>
3527        /// <param name="tree_iterator"></param>
3528        /// <returns></returns>
3529        public static T PrevTreeNode<T>(this CvTreeNodeIterator tree_iterator) where T : CvArr
3530        {
3531            if (tree_iterator == null)
3532            {
3533                throw new ArgumentNullException("tree_iterator");
3534            }
3535            IntPtr result = CvDll.cvPrevTreeNode(tree_iterator);
3536            if (result == IntPtr.Zero)
3537            {
3538                return null;
3539            }
3540            else
3541            {
3542                return Cast<T>(result);
3543            }
3544        }
3545        /// <summary>
3546        ///
3547        /// </summary>
3548        /// <typeparam name="T"></typeparam>
3549        /// <param name="tree_iterator"></param>
3550        /// <returns></returns>
3551        public static T PrevTreeNode<T>(this CvTreeNodeIterator<T> tree_iterator) where T : CvArr
3552        {
3553            return PrevTreeNode<T>((CvTreeNodeIterator)tree_iterator);
3554        }
3555        #endregion
3556        #region ProjectPCA
3557#if LANG_JP
3558        /// <summary>
3559        ///
3560        /// </summary>
3561        /// <param name="data"></param>
3562        /// <param name="avg"></param>
3563        /// <param name="eigenvects"></param>
3564        /// <param name="result"></param>
3565        /// <returns></returns>
3566#else
3567        /// <summary>
3568        /// Projects vectors to the specified subspace
3569        /// </summary>
3570        /// <param name="data">The input data; each vector is either a single row or a single column. </param>
3571        /// <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>
3572        /// <param name="eigenvects">The eigenvectors (principal components); one vector per row. </param>
3573        /// <param name="result">The output matrix of decomposition coefficients. The number of rows must be the same as the number of vectors, the number of columns must be less than or equal to the number of rows in eigenvectors. That it is less, the input vectors are projected into subspace of the first cols(result) principal components.</param>
3574        /// <returns></returns>
3575#endif
3576        public static void ProjectPCA(CvArr data, CvArr avg, CvArr eigenvects, CvArr result)
3577        {
3578            if (data == null)
3579            {
3580                throw new ArgumentNullException("data");
3581            }
3582            if (avg == null)
3583            {
3584                throw new ArgumentNullException("avg");
3585            }
3586            if (eigenvects == null)
3587            {
3588                throw new ArgumentNullException("eigenvects");
3589            }
3590            CvDll.cvProjectPCA(data.CvPtr, avg.CvPtr, eigenvects.CvPtr, result.CvPtr);
3591        }
3592        #endregion
3593        #region ProjectPoints2
3594        /// <summary>
3595        /// 次元空間中の点を画像平面上に投影した際の座標を,内部パラメータと外部パラメータを用いて計算する.
3596        /// オプションとして,この関数は画像中の投影点の偏微分係数行列であるヤコビアンを求める.
3597        /// </summary>
3598        /// <remarks>
3599        /// 内部パラメータ及び/または外部パラメータを特別な値に設定すると,
3600        /// この関数を外部変換のみ,あるいは内部変換のみ(つまり,疎な点集 合の歪みを考慮したものに変換する)を計算するために利用することができる.
3601        /// </remarks>
3602        /// <param name="object_points">オブジェクトの点の配列でその大きさは3xNまたはNx3である.N は画像内の点の個数</param>
3603        /// <param name="rotation_vector">回転ベクトル.1x3または3x1</param>
3604        /// <param name="translation_vector">並進ベクトル.1x3または3x1</param>
3605        /// <param name="intrinsic_matrix">カメラマトリクス(A) [fx 0 cx; 0 fy cy; 0 0 1]</param>
3606        /// <param name="distortion_coeffs">歪み係数.4x1または1x4 [k1, k2, p1, p2]. NULLの場合,すべての歪み係数を0とする</param>
3607        /// <param name="image_points">画像平面上の点の出力配列で,その大きさは2xNまたはNx2である.ここでNはビュー上の点の数</param>
3608        public static void ProjectPoints2(CvMat object_points, CvMat rotation_vector, CvMat translation_vector, CvMat intrinsic_matrix, CvMat distortion_coeffs, CvMat image_points)
3609        {
3610            ProjectPoints2(object_points, rotation_vector, translation_vector, intrinsic_matrix, distortion_coeffs, image_points, null, null, null, null, null, 0);
3611        }
3612        /// <summary>
3613        /// 次元空間中の点を画像平面上に投影した際の座標を,内部パラメータと外部パラメータを用いて計算する.
3614        /// オプションとして,この関数は画像中の投影点の偏微分係数行列であるヤコビアンを求める.
3615        /// </summary>
3616        /// <remarks>
3617        /// 内部パラメータ及び/または外部パラメータを特別な値に設定すると,
3618        /// この関数を外部変換のみ,あるいは内部変換のみ(つまり,疎な点集 合の歪みを考慮したものに変換する)を計算するために利用することができる.
3619        /// </remarks>
3620        /// <param name="object_points">オブジェクトの点の配列でその大きさは3xNまたはNx3である.N は画像内の点の個数</param>
3621        /// <param name="rotation_vector">回転ベクトル.1x3または3x1</param>
3622        /// <param name="translation_vector">並進ベクトル.1x3または3x1</param>
3623        /// <param name="intrinsic_matrix">カメラマトリクス(A) [fx 0 cx; 0 fy cy; 0 0 1]</param>
3624        /// <param name="distortion_coeffs">歪み係数.4x1または1x4 [k1, k2, p1, p2]. NULLの場合,すべての歪み係数を0とする</param>
3625        /// <param name="image_points">画像平面上の点の出力配列で,その大きさは2xNまたはNx2である.ここでNはビュー上の点の数</param>
3626        /// <param name="dpdrot">オプション:画像平面上の点の回転ベクトルの各要素に関する微分係数を表す2Nx3行列</param>
3627        /// <param name="dpdt">オプション:画像平面上の点の並進ベクトルの各要素に関する微分係数を表す2Nx3行列</param>
3628        /// <param name="dpdf">オプション:画像平面上の点のfx と fyに関する微分係数を表す2Nx2行列</param>
3629        /// <param name="dpdc">オプション:画像平面上の点のcx とcyに関する微分係数を表す2Nx2行列</param>
3630        /// <param name="dpddist">オプション:画像平面上の点の歪み係数に関する微分係数を表す2Nx4行列</param>
3631        public static void ProjectPoints2(CvMat object_points, CvMat rotation_vector, CvMat translation_vector, CvMat intrinsic_matrix, CvMat distortion_coeffs, CvMat image_points, CvMat dpdrot, CvMat dpdt, CvMat dpdf, CvMat dpdc, CvMat dpddist)
3632        {
3633            ProjectPoints2(object_points, rotation_vector, translation_vector, intrinsic_matrix, distortion_coeffs, image_points, dpdrot, dpdt, dpdf, dpdc, dpddist, 0);
3634        }
3635        /// <summary>
3636        /// 次元空間中の点を画像平面上に投影した際の座標を,内部パラメータと外部パラメータを用いて計算する.
3637        /// オプションとして,この関数は画像中の投影点の偏微分係数行列であるヤコビアンを求める.
3638        /// </summary>
3639        /// <remarks>
3640        /// 内部パラメータ及び/または外部パラメータを特別な値に設定すると,
3641        /// この関数を外部変換のみ,あるいは内部変換のみ(つまり,疎な点集 合の歪みを考慮したものに変換する)を計算するために利用することができる.
3642        /// </remarks>
3643        /// <param name="object_points">オブジェクトの点の配列でその大きさは3xNまたはNx3である.N は画像内の点の個数</param>
3644        /// <param name="rotation_vector">回転ベクトル.1x3または3x1</param>
3645        /// <param name="translation_vector">並進ベクトル.1x3または3x1</param>
3646        /// <param name="intrinsic_matrix">カメラマトリクス(A) [fx 0 cx; 0 fy cy; 0 0 1]</param>
3647        /// <param name="distortion_coeffs">歪み係数.4x1または1x4 [k1, k2, p1, p2]. NULLの場合,すべての歪み係数を0とする</param>
3648        /// <param name="image_points">画像平面上の点の出力配列で,その大きさは2xNまたはNx2である.ここでNはビュー上の点の数</param>
3649        /// <param name="dpdrot">オプション:画像平面上の点の回転ベクトルの各要素に関する微分係数を表す2Nx3行列</param>
3650        /// <param name="dpdt">オプション:画像平面上の点の並進ベクトルの各要素に関する微分係数を表す2Nx3行列</param>
3651        /// <param name="dpdf">オプション:画像平面上の点のfx と fyに関する微分係数を表す2Nx2行列</param>
3652        /// <param name="dpdc">オプション:画像平面上の点のcx とcyに関する微分係数を表す2Nx2行列</param>
3653        /// <param name="dpddist">オプション:画像平面上の点の歪み係数に関する微分係数を表す2Nx4行列</param>
3654        /// <param name="aspect_ratio"></param>
3655        public static void ProjectPoints2(CvMat object_points, CvMat rotation_vector, CvMat translation_vector, CvMat intrinsic_matrix, CvMat distortion_coeffs, CvMat image_points, CvMat dpdrot, CvMat dpdt, CvMat dpdf, CvMat dpdc, CvMat dpddist, double aspect_ratio)
3656        {
3657            if (object_points == null)
3658                throw new ArgumentNullException("object_points");
3659            if (rotation_vector == null)
3660                throw new ArgumentNullException("rotation_vector");
3661            if (translation_vector == null)
3662                throw new ArgumentNullException("translation_vector");
3663            if (intrinsic_matrix == null)
3664                throw new ArgumentNullException("intrinsic_matrix");
3665            if (distortion_coeffs == null)
3666                throw new ArgumentNullException("distortion_coeffs");
3667            if (image_points == null)
3668                throw new ArgumentNullException("image_points");
3669            IntPtr dpdrotPtr = (dpdrot == null) ? IntPtr.Zero : dpdrot.CvPtr;
3670            IntPtr dpdtPtr = (dpdt == null) ? IntPtr.Zero : dpdt.CvPtr;
3671            IntPtr dpdfPtr = (dpdf == null) ? IntPtr.Zero : dpdf.CvPtr;
3672            IntPtr dpdcPtr = (dpdc == null) ? IntPtr.Zero : dpdc.CvPtr;
3673            IntPtr dpddistPtr = (dpddist == null) ? IntPtr.Zero : dpddist.CvPtr;
3674            CvDll.cvProjectPoints2(object_points.CvPtr, rotation_vector.CvPtr, translation_vector.CvPtr, intrinsic_matrix.CvPtr, distortion_coeffs.CvPtr, image_points.CvPtr, dpdrotPtr, dpdtPtr, dpdfPtr, dpdcPtr, dpddistPtr, aspect_ratio);
3675        }
3676        #endregion
3677        #region Ptr*D
3678        /// <summary>
3679        /// 特定の配列要素へのポインタを返す.
3680        /// この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3681        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3682        /// </summary>
3683        /// <param name="arr">入力配列</param>
3684        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
3685        /// <returns>指定した要素のポインタ</returns>
3686        public static IntPtr Ptr1D(this CvArr arr, int idx0)
3687        {
3688            MatrixType type;
3689            return CvDll.cvPtr1D(arr.CvPtr, idx0, out type);
3690        }
3691        /// <summary>
3692        /// 特定の配列要素へのポインタを返す.
3693        /// この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3694        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3695        /// </summary>
3696        /// <param name="arr">入力配列</param>
3697        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
3698        /// <param name="type">行列要素のタイプ</param>
3699        /// <returns>指定した要素のポインタ</returns>
3700        public static IntPtr Ptr1D(this CvArr arr, int idx0, out MatrixType type)
3701        {
3702            return CvDll.cvPtr1D(arr.CvPtr, idx0, out type);
3703        }
3704        /// <summary>
3705        /// 特定の配列要素へのポインタを返す.
3706        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3707        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3708        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3709        /// </summary>
3710        /// <param name="arr">入力配列</param>
3711        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
3712        /// <param name="idx1">要素インデックスの,0を基準とした第2成分.</param>
3713        /// <returns>指定した要素のポインタ</returns>
3714        public static IntPtr Ptr2D(this CvArr arr, int idx0, int idx1)
3715        {
3716            MatrixType type;
3717            return CvDll.cvPtr2D(arr.CvPtr, idx0, idx1, out type);
3718        }
3719        /// <summary>
3720        /// 特定の配列要素へのポインタを返す.
3721        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3722        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3723        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3724        /// </summary>
3725        /// <param name="arr">入力配列</param>
3726        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
3727        /// <param name="idx1">要素インデックスの,0を基準とした第2成分.</param>
3728        /// <param name="type">行列要素のタイプ</param>
3729        /// <returns>指定した要素のポインタ</returns>
3730        public static IntPtr Ptr2D(this CvArr arr, int idx0, int idx1, MatrixType type)
3731        {
3732            return CvDll.cvPtr2D(arr.CvPtr, idx0, idx1, out type);
3733        }
3734        /// <summary>
3735        /// 特定の配列要素へのポインタを返す.
3736        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3737        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3738        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3739        /// </summary>
3740        /// <param name="arr">入力配列</param>
3741        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
3742        /// <param name="idx1">要素インデックスの,0を基準とした第2成分.</param>
3743        /// <param name="idx2">要素インデックスの,0を基準とした第3成分.</param>
3744        /// <returns>指定した要素のポインタ</returns>
3745        public static IntPtr Ptr3D(this CvArr arr, int idx0, int idx1, int idx2)
3746        {
3747            MatrixType type;
3748            return CvDll.cvPtr3D(arr.CvPtr, idx0, idx1, idx2, out type);
3749        }
3750        /// <summary>
3751        /// 特定の配列要素へのポインタを返す.
3752        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3753        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3754        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3755        /// </summary>
3756        /// <param name="arr">入力配列</param>
3757        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
3758        /// <param name="idx1">要素インデックスの,0を基準とした第2成分.</param>
3759        /// <param name="idx2">要素インデックスの,0を基準とした第3成分.</param>
3760        /// <param name="type">行列要素のタイプ</param>
3761        /// <returns>指定した要素のポインタ</returns>
3762        public static IntPtr Ptr3D(this CvArr arr, int idx0, int idx1, int idx2, MatrixType type)
3763        {
3764            return CvDll.cvPtr3D(arr.CvPtr, idx0, idx1, idx2, out type);
3765        }
3766        /// <summary>
3767        /// 特定の配列要素へのポインタを返す.
3768        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3769        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3770        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3771        /// </summary>
3772        /// <param name="arr">入力配列</param>
3773        /// <param name="idx">要素インデックスの配列(可変長引数)</param>
3774        /// <returns>指定した要素のポインタ</returns>
3775        public static IntPtr PtrND(this CvArr arr, params int[] idx)
3776        {
3777            MatrixType type;
3778            return CvDll.cvPtrND(arr.CvPtr, idx, out type, true, IntPtr.Zero);
3779        }
3780        /// <summary>
3781        /// 特定の配列要素へのポインタを返す.
3782        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3783        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3784        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3785        /// </summary>
3786        /// <param name="arr">入力配列</param>
3787        /// <param name="idx">要素インデックスの配列</param>
3788        /// <param name="type">行列要素のタイプ</param>
3789        /// <returns>指定した要素のポインタ</returns>
3790        public static IntPtr PtrND(this CvArr arr, int[] idx, MatrixType type)
3791        {
3792            return CvDll.cvPtrND(arr.CvPtr, idx, out type, true, IntPtr.Zero);
3793        }
3794        /// <summary>
3795        /// 特定の配列要素へのポインタを返す.
3796        /// 配列の次元数は関数の引き数として渡されるインデックスの数と一致しなければならない.
3797        /// 同様に,この関数は,疎な配列に対しても用いられる.指定したノードが存在しない場合,関数はそれを生成し,0をセットする.
3798        /// 要素のインデックスが範囲外であれば,エラーが起こる.
3799        /// </summary>
3800        /// <param name="arr">入力配列</param>
3801        /// <param name="idx">要素インデックスの配列</param>
3802        /// <param name="type">行列要素のタイプ</param>
3803        /// <param name="create_node">疎な行列に対するオプションの入力パラメータ. trueの場合,指定された要素が存在しないときは要素を生成する.</param>
3804        /// <returns>指定した要素のポインタ</returns>
3805        public static IntPtr PtrND(this CvArr arr, int[] idx, MatrixType type, bool create_node)
3806        {
3807            return CvDll.cvPtrND(arr.CvPtr, idx, out type, create_node, IntPtr.Zero);
3808        }
3809        #endregion
3810        #region PutText
3811        /// <summary>
3812        /// 指定したフォントと色で文字列を画像中に描画する.描画された文字はROIによって切り取られる.
3813        /// 指定したフォントに含まれない記号は四角で置き換えられる.
3814        /// </summary>
3815        /// <param name="img">入力画像</param>
3816        /// <param name="text">描画する文字列</param>
3817        /// <param name="org">最初の文字の左下の座標</param>
3818        /// <param name="font">フォント構造体</param>
3819        /// <param name="color">文字の色</param>
3820        public static void PutText(this CvArr img, string text, CvPoint org, CvFont font, CvColor color)
3821        {
3822            if (img == null)
3823                throw new ArgumentNullException("img");
3824            if (text == null)
3825                throw new ArgumentNullException("text");
3826            if (font == null)
3827                throw new ArgumentNullException("font");
3828            CvDll.cvPutText(img.CvPtr, text, org, font.CvPtr, color);
3829        }
3830        #endregion
3831        #region PyrDown
3832#if LANG_JP
3833        /// <summary>
3834        /// 画像のダウンサンプリングを行う
3835        /// </summary>
3836        /// <param name="src">入力画像</param>
3837        /// <param name="dst">出力画像.入力画像の1/2の幅と高さ.</param>
3838#else
3839        /// <summary>
3840        /// Downsamples image.
3841        /// </summary>
3842        /// <param name="src">The source image. </param>
3843        /// <param name="dst">The destination image, should have 2x smaller width and height than the source. </param>
3844#endif
3845        public static void PyrDown(this CvArr src, CvArr dst)
3846        {
3847            PyrDown(src, dst, CvFilter.Gaussian5x5);
3848        }
3849#if LANG_JP
3850        /// <summary>
3851        /// 画像のダウンサンプリングを行う
3852        /// </summary>
3853        /// <param name="src">入力画像</param>
3854        /// <param name="dst">出力画像.入力画像の1/2の幅と高さ.</param>
3855        /// <param name="filter">畳み込みに使うフィルタ.現在は CV_GAUSSIAN_5x5 のみサポート.</param>
3856#else
3857        /// <summary>
3858        /// Downsamples image.
3859        /// </summary>
3860        /// <param name="src">The source image. </param>
3861        /// <param name="dst">The destination image, should have 2x smaller width and height than the source. </param>
3862        /// <param name="filter">Type of the filter used for convolution; only CV_GAUSSIAN_5x5 is currently supported. </param>
3863#endif
3864        public static void PyrDown(this CvArr src, CvArr dst, CvFilter filter)
3865        {
3866            if (src == null)
3867                throw new ArgumentNullException("src");
3868            if (dst == null)
3869                throw new ArgumentNullException("dst");
3870            CvDll.cvPyrDown(src.CvPtr, dst.CvPtr, filter);
3871        }
3872        #endregion
3873        #region PyrMeanShiftFiltering
3874#if LANG_JP
3875        /// <summary>
3876        /// 平均値シフト法による画像のセグメント化アルゴリズムのフィルタリング部分を実装する.
3877        /// </summary>
3878        /// <param name="src">入力画像.8ビット,3チャンネル</param>
3879        /// <param name="dst">出力画像.入力画像と同じフォーマット,同じサイズ</param>
3880        /// <param name="sp">空間ウィンドウの半径</param>
3881        /// <param name="sr">色空間ウィンドウの半径</param>
3882#else
3883        /// <summary>
3884        /// Does meanshift image segmentation.
3885        /// </summary>
3886        /// <param name="src">The source 8-bit 3-channel image. </param>
3887        /// <param name="dst">The destination image of the same format and the same size as the source. </param>
3888        /// <param name="sp">The spatial window radius. </param>
3889        /// <param name="sr">The color window radius. </param>
3890#endif
3891        public static void PyrMeanShiftFiltering(this CvArr src, CvArr dst, double sp, double sr)
3892        {
3893            PyrMeanShiftFiltering(src, dst, sp, sr, 1, new CvTermCriteria(CriteriaType.Iteration | CriteriaType.Epsilon, 5, 1));
3894        }
3895#if LANG_JP
3896        /// <summary>
3897        /// 平均値シフト法による画像のセグメント化アルゴリズムのフィルタリング部分を実装する.
3898        /// </summary>
3899        /// <param name="src">入力画像.8ビット,3チャンネル</param>
3900        /// <param name="dst">出力画像.入力画像と同じフォーマット,同じサイズ</param>
3901        /// <param name="sp">空間ウィンドウの半径</param>
3902        /// <param name="sr">色空間ウィンドウの半径</param>
3903        /// <param name="max_level">セグメント化のためのピラミッドの最大レベル</param>
3904#else
3905        /// <summary>
3906        /// Does meanshift image segmentation.
3907        /// </summary>
3908        /// <param name="src">The source 8-bit 3-channel image. </param>
3909        /// <param name="dst">The destination image of the same format and the same size as the source. </param>
3910        /// <param name="sp">The spatial window radius. </param>
3911        /// <param name="sr">The color window radius. </param>
3912        /// <param name="max_level">Maximum level of the pyramid for the segmentation. </param>
3913#endif
3914        public static void PyrMeanShiftFiltering(this CvArr src, CvArr dst, double sp, double sr, int max_level)
3915        {
3916            PyrMeanShiftFiltering(src, dst, sp, sr, max_level, new CvTermCriteria(CriteriaType.Iteration | CriteriaType.Epsilon, 5, 1));
3917        }
3918#if LANG_JP
3919        /// <summary>
3920        /// 平均値シフト法による画像のセグメント化アルゴリズムのフィルタリング部分を実装する.
3921        /// </summary>
3922        /// <param name="src">入力画像.8ビット,3チャンネル</param>
3923        /// <param name="dst">出力画像.入力画像と同じフォーマット,同じサイズ</param>
3924        /// <param name="sp">空間ウィンドウの半径</param>
3925        /// <param name="sr">色空間ウィンドウの半径</param>
3926        /// <param name="max_level">セグメント化のためのピラミッドの最大レベル</param>
3927        /// <param name="termcrit">終了条件.平均値シフトをいつまで繰り返すか</param>
3928#else
3929        /// <summary>
3930        /// Does meanshift image segmentation.
3931        /// </summary>
3932        /// <param name="src">The source 8-bit 3-channel image. </param>
3933        /// <param name="dst">The destination image of the same format and the same size as the source. </param>
3934        /// <param name="sp">The spatial window radius. </param>
3935        /// <param name="sr">The color window radius. </param>
3936        /// <param name="max_level">Maximum level of the pyramid for the segmentation. </param>
3937        /// <param name="termcrit">Termination criteria: when to stop meanshift iterations. </param>
3938#endif
3939        public static void PyrMeanShiftFiltering(this CvArr src, CvArr dst, double sp, double sr, int max_level, CvTermCriteria termcrit)
3940        {
3941            if (src == null)
3942                throw new ArgumentNullException("src");
3943            if (dst == null)
3944                throw new ArgumentNullException("dst");
3945            CvDll.cvPyrMeanShiftFiltering(src.CvPtr, dst.CvPtr, sp, sr, max_level, termcrit);
3946        }
3947        #endregion
3948        #region PyrSegmentation
3949#if LANG_JP
3950        /// <summary>
3951        /// 画像ピラミッドによる画像のセグメント化を実装する.ピラミッドは,levelまで作成する.(out引数のcompがいらないときバージョン)
3952        /// </summary>
3953        /// <param name="src">入力画像</param>
3954        /// <param name="dst">出力画像</param>
3955        /// <param name="level">セグメント化のためのピラミッドの最大レベル</param>
3956        /// <param name="threshold1">リンク構築のための誤差閾値</param>
3957        /// <param name="threshold2">セグメントクラスタリングのための誤差閾値</param>
3958#else
3959        /// <summary>
3960        /// Does image segmentation by pyramids.
3961        /// </summary>
3962        /// <param name="src">The source image. </param>
3963        /// <param name="dst">The destination image. </param>
3964        /// <param name="level"></param>
3965        /// <param name="threshold1"></param>
3966        /// <param name="threshold2"></param>
3967#endif
3968        public static void PyrSegmentation(this IplImage src, IplImage dst, int level, double threshold1, double threshold2)
3969        {
3970            CvMemStorage storage = new CvMemStorage();
3971            CvSeq comp;
3972            PyrSegmentation(src, dst, storage, out comp, level, threshold1, threshold2);
3973        }
3974#if LANG_JP
3975        /// <summary>
3976        /// 画像ピラミッドによる画像のセグメント化を実装する. ピラミッドは,levelまで作成する.
3977        /// </summary>
3978        /// <param name="src">入力画像</param>
3979        /// <param name="dst">出力画像</param>
3980        /// <param name="storage">結果として得られる連結成分のシーケンスを保存するための領域</param>
3981        /// <param name="comp">セグメント化された成分の出力シーケンスへのポインタ</param>
3982        /// <param name="level">セグメント化のためのピラミッドの最大レベル</param>
3983        /// <param name="threshold1">リンク構築のための誤差閾値</param>
3984        /// <param name="threshold2">セグメントクラスタリングのための誤差閾値</param>
3985#else
3986        /// <summary>
3987        /// Does image segmentation by pyramids.
3988        /// </summary>
3989        /// <param name="src">The source image. </param>
3990        /// <param name="dst">The destination image. </param>
3991        /// <param name="storage">Storage; stores the resulting sequence of connected components. </param>
3992        /// <param name="comp">Pointer to the output sequence of the segmented components. </param>
3993        /// <param name="level">Maximum level of the pyramid for the segmentation. </param>
3994        /// <param name="threshold1">Error threshold for establishing the links. </param>
3995        /// <param name="threshold2">Error threshold for the segments clustering. </param>
3996#endif
3997        public static void PyrSegmentation(this IplImage src, IplImage dst, CvMemStorage storage, out CvSeq comp, int level, double threshold1, double threshold2)
3998        {
3999            if (src == null)
4000                throw new ArgumentNullException("src");
4001            if (dst == null)
4002                throw new ArgumentNullException("dst");
4003            if (src == null)
4004                throw new ArgumentNullException("src");
4005            IntPtr compPtr;
4006            CvDll.cvPyrSegmentation(src.CvPtr, dst.CvPtr, storage.CvPtr, out compPtr, level, threshold1, threshold2);
4007            comp = new CvSeq(compPtr);
4008        }
4009        #endregion
4010        #region PyrUp
4011#if LANG_JP
4012        /// <summary>
4013        /// 画像のアップサンプリングを行う
4014        /// </summary>
4015        /// <param name="src">入力画像</param>
4016        /// <param name="dst">出力画像.入力画像の1/2の幅と高さ.</param>
4017#else
4018        /// <summary>
4019        /// Upsamples image.
4020        /// </summary>
4021        /// <param name="src">The source image. </param>
4022        /// <param name="dst">The destination image, should have 2x smaller width and height than the source. </param>
4023#endif
4024        public static void PyrUp(this CvArr src, CvArr dst)
4025        {
4026            PyrUp(src, dst, CvFilter.Gaussian5x5);
4027        }
4028#if LANG_JP
4029        /// <summary>
4030        /// 画像のアップサンプリングを行う
4031        /// </summary>
4032        /// <param name="src">入力画像</param>
4033        /// <param name="dst">出力画像.入力画像の1/2の幅と高さ.</param>
4034        /// <param name="filter">畳み込みに使うフィルタ.現在は CV_GAUSSIAN_5x5 のみサポート.</param>
4035#else
4036        /// <summary>
4037        /// Upsamples image.
4038        /// </summary>
4039        /// <param name="src">The source image. </param>
4040        /// <param name="dst">The destination image, should have 2x smaller width and height than the source. </param>
4041        /// <param name="filter">Type of the filter used for convolution; only CV_GAUSSIAN_5x5 is currently supported. </param>
4042#endif
4043        public static void PyrUp(this CvArr src, CvArr dst, CvFilter filter)
4044        {
4045            if (src == null)
4046                throw new ArgumentNullException("src");
4047            if (dst == null)
4048                throw new ArgumentNullException("dst");
4049            CvDll.cvPyrUp(src.CvPtr, dst.CvPtr, filter);
4050        }
4051        #endregion
4052        #region QueryFrame
4053#if LANG_JP
4054        /// <summary>
4055        /// カメラやビデオファイルから一つのフレームを取り出し,それを展開して返す.
4056        /// この関数は,単純にcvGrabFrame とcvRetrieveFrame をまとめて呼び出しているだけである.
4057        /// 返された画像は,ユーザが解放したり,変更したりするべきではない.
4058        /// </summary>
4059        /// <param name="capture">ビデオキャプチャクラス</param>
4060        /// <returns>1フレームの画像 (GC禁止フラグが立っている). キャプチャできなかった場合はnull.</returns>
4061#else
4062        /// <summary>
4063        /// Grabs a frame from camera or video file, decompresses and returns it.
4064        /// This function is just a combination of cvGrabFrame and cvRetrieveFrame in one call.
4065        /// The returned image should not be released or modified by user.
4066        /// </summary>
4067        /// <param name="capture">video capturing structure. </param>
4068        /// <returns></returns>
4069#endif
4070        public static IplImage QueryFrame(this CvCapture capture)
4071        {
4072            if (capture == null)
4073            {
4074                throw new ArgumentNullException("capture");
4075            }
4076            IntPtr ptr = CvDll.cvQueryFrame(capture.CvPtr);
4077            if (ptr == IntPtr.Zero)
4078                return null;
4079            else
4080                return new IplImage(ptr, false);
4081        }
4082        #endregion
4083        #region QueryHistValue_*D
4084#if LANG_JP
4085        /// <summary>
4086        /// 1次元ヒストグラムの指定されたビンの値を返す.
4087        /// 疎なヒストグラムの場合で,既にビンが存在している場合以外は,この関数が新しいビンを作成し,0にセットする.
4088        /// </summary>
4089        /// <param name="hist">ヒストグラム</param>
4090        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
4091        /// <returns>指定した要素の値</returns>
4092#else
4093        /// <summary>
4094        /// Queries value of histogram bin.
4095        /// </summary>
4096        /// <param name="hist">Histogram. </param>
4097        /// <param name="idx0">1st index of the bin.</param>
4098        /// <returns></returns>
4099#endif
4100        public static double QueryHistValue_1D(CvHistogram hist, int idx0)
4101        {
4102            return CvInline.cvQueryHistValue_1D_(hist.CvPtr, idx0);
4103        }
4104#if LANG_JP
4105        /// <summary>
4106        /// 2次元ヒストグラムの指定されたビンの値を返す.
4107        /// 疎なヒストグラムの場合で,既にビンが存在している場合以外は,この関数が新しいビンを作成し,0にセットする.
4108        /// </summary>
4109        /// <param name="hist">ヒストグラム</param>
4110        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
4111        /// <param name="idx1">要素インデックスの,0を基準とした第2成分.</param>
4112        /// <returns>指定した要素の値</returns>
4113#else
4114        /// <summary>
4115        /// Queries value of histogram bin.
4116        /// </summary>
4117        /// <param name="hist">Histogram. </param>
4118        /// <param name="idx0">1st index of the bin.</param>
4119        /// <param name="idx1">2nd index of the bin.</param>
4120        /// <returns></returns>
4121#endif
4122        public static double QueryHistValue_2D(CvHistogram hist, int idx0, int idx1)
4123        {
4124            return CvInline.cvQueryHistValue_2D_(hist.CvPtr, idx0, idx1);
4125        }
4126#if LANG_JP
4127        /// <summary>
4128        /// 3次元ヒストグラムの指定されたビンの値を返す.
4129        /// 疎なヒストグラムの場合で,既にビンが存在している場合以外は,この関数が新しいビンを作成し,0にセットする.
4130        /// </summary>
4131        /// <param name="hist">ヒストグラム</param>
4132        /// <param name="idx0">要素インデックスの,0を基準とした第1成分.</param>
4133        /// <param name="idx1">要素インデックスの,0を基準とした第2成分.</param>
4134        /// <param name="idx2">要素インデックスの,0を基準とした第3成分.</param>
4135        /// <returns>指定した要素の値</returns>
4136#else
4137        /// <summary>
4138        /// Queries value of histogram bin.
4139        /// </summary>
4140        /// <param name="hist">Histogram. </param>
4141        /// <param name="idx0">1st index of the bin.</param>
4142        /// <param name="idx1">2nd index of the bin.</param>
4143        /// <param name="idx2">3rd index of the bin.</param>
4144        /// <returns></returns>
4145#endif
4146        public static double QueryHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
4147        {
4148            return CvInline.cvQueryHistValue_3D_(hist.CvPtr, idx0, idx1, idx2);
4149        }
4150#if LANG_JP
4151        /// <summary>
4152        /// n次元ヒストグラムの指定されたビンの値を返す.
4153        /// 疎なヒストグラムの場合で,既にビンが存在している場合以外は,この関数が新しいビンを作成し,0にセットする.
4154        /// </summary>
4155        /// <param name="hist">ヒストグラム</param>
4156        /// <param name="idx">要素インデックスの配列(可変長引数)</param>
4157        /// <returns>指定した要素の値</returns>
4158#else
4159        /// <summary>
4160        /// Queries value of histogram bin.
4161        /// </summary>
4162        /// <param name="hist">1st index of the bin.</param>
4163        /// <param name="idx">Array of indices.</param>
4164        /// <returns></returns>
4165#endif
4166        public static double QueryHistValue_nD(CvHistogram hist, params int[] idx)
4167        {
4168            return CvInline.cvQueryHistValue_nD_(hist.CvPtr, idx);
4169        }
4170        #endregion
4171    }
4172}
Note: See TracBrowser for help on using the browser.