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

Revision 32620, 246.5 kB (checked in by schima, 6 years ago)

WCvConDensation

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