root/lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Src/CvArr/CvMat.cs @ 32652

Revision 32652, 38.5 kB (checked in by schima, 6 years ago)

cvUseOptimized, cvFree, cvGetNumThreads, cvSetNumThreads, cvGetThreadNum

Line 
1using System;
2using System.Collections.Generic;
3using System.IO;
4using System.Linq;
5using System.Runtime.InteropServices;
6using System.Text;
7using KwsmLab.OpenCvSharp.Extern;
8
9namespace KwsmLab.OpenCvSharp
10{
11#if LANG_JP
12    /// <summary>
13    /// 多重行列
14    /// </summary>
15#else
16    /// <summary>
17    /// Multi-channel matrix
18    /// </summary>
19#endif
20    public class CvMat : CvArr, ICloneable
21    {
22        #region Variables
23        /// <summary>
24        /// C++/CLI側でポインタにアクセスするオブジェクト
25        /// </summary>
26        private Extern.WCvMat data;
27        /// <summary>
28        /// データポインタ
29        /// </summary>
30        private IntPtr ptr;
31
32        /// <summary>
33        ///
34        /// </summary>
35        private PointerAccessor.Byte1 dataArrayByte;
36        /// <summary>
37        ///
38        /// </summary>
39        private PointerAccessor.Short1 dataArrayShort;
40        /// <summary>
41        ///
42        /// </summary>
43        private PointerAccessor.Int1 dataArrayInt;
44        /// <summary>
45        ///
46        /// </summary>
47        private PointerAccessor.Float1 dataArrayFloat;
48        /// <summary>
49        ///
50        /// </summary>
51        private PointerAccessor.Double1 dataArrayDouble;
52        #endregion
53
54
55        #region Initialization and Disposal
56#if LANG_JP
57        /// <summary>
58        /// 新たな行列とその内部データのためのヘッダを確保する
59        /// </summary>
60        /// <param name="rows">行列の行数</param>
61        /// <param name="cols">行列の列数</param>
62        /// <param name="type">行列要素の種類</param>
63        /// <returns>行列</returns>
64#else
65        /// <summary>
66        /// Allocates header for the new matrix and underlying data, and returns a pointer to the created matrix.
67        /// </summary>
68        /// <param name="rows">Number of rows in the matrix. </param>
69        /// <param name="cols">Number of columns in the matrix. </param>
70        /// <param name="type">Type of the matrix elements.</param>
71        /// <returns></returns>
72#endif
73        public CvMat(int rows, int cols, MatrixType type)
74        {
75            this.ptr = CvDll.cvCreateMat(rows, cols, type);
76            if (this.ptr == IntPtr.Zero)
77            {
78                throw new OpenCvSharpException("Failed to create CvMat");
79            }
80            this.data = new Extern.WCvMat(this.ptr);
81            NotifyMemoryPressure(SizeOf);
82        }
83#if LANG_JP
84        /// <summary>
85        /// 新たな行列とその内部データのためのヘッダを確保し、内部データに指定した配列を指定する
86        /// </summary>
87        /// <param name="rows">行列の行数</param>
88        /// <param name="cols">行列の列数</param>
89        /// <param name="type">行列要素の種類</param>
90        /// <param name="elements">行列要素とする配列. blittableな型の配列でなければならない(intやCvPointなど)</param>
91        /// <returns>行列</returns>
92#else
93        /// <summary>
94        /// Allocates header for the new matrix and underlying data, and returns a pointer to the created matrix.
95        /// </summary>
96        /// <param name="rows">Number of rows in the matrix. </param>
97        /// <param name="cols">Number of columns in the matrix. </param>
98        /// <param name="type">Type of the matrix elements.</param>
99        /// <param name="elements">Data of elements. The type of the array must be blittable.</param>
100        /// <returns></returns>
101#endif
102        public CvMat(int rows, int cols, MatrixType type, Array elements)
103            : this(rows, cols, type)
104        {
105            GCHandle gch = base.AllocGCHandle(elements);
106            CvDll.cvSetData(CvPtr, gch.AddrOfPinnedObject(), Cv.AUTOSTEP);
107        }
108
109#if LANG_JP
110        /// <summary>
111        /// 指定されたファイルから画像を読み込んで初期化
112        /// </summary>
113        /// <param name="filename">ファイル名</param>
114#else
115        /// <summary>
116        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat.
117        /// </summary>
118        /// <param name="filename">Name of file to be loaded. </param>
119        /// <returns>the reference to the loaded image. </returns>
120#endif
121        public CvMat(string filename)
122            : this(filename, LoadMode.Color)
123        {
124        }
125#if LANG_JP
126        /// <summary>
127        /// 指定されたファイルから画像を読み込んで初期化
128        /// </summary>
129        /// <param name="filename">ファイル名</param>
130        /// <param name="flags">読み込む画像がカラー/グレースケールのどちらか,とビット深度を指定する</param>
131#else
132        /// <summary>
133        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat.
134        /// </summary>
135        /// <param name="filename">Name of file to be loaded. </param>
136        /// <param name="flags">Specifies colorness and Depth of the loaded image.</param>
137        /// <returns>the reference to the loaded image. </returns>
138#endif
139        public CvMat(string filename, LoadMode flags)
140        {
141            if (string.IsNullOrEmpty(filename))
142            {
143                throw new ArgumentNullException("filename");
144            }
145            if (!File.Exists(filename))
146            {
147                throw new FileNotFoundException("", filename);
148            }
149            this.ptr = CvDll.cvLoadImageM(filename, flags);
150            if (this.ptr == IntPtr.Zero)
151            {
152                throw new OpenCvSharpException("Failed to create CvMat");
153            }
154            this.data = new Extern.WCvMat(ptr);
155            base.NotifyMemoryPressure(SizeOf);
156        }
157
158        /// <summary>
159        /// ポインタから初期化
160        /// </summary>
161        /// <param name="ptr"></param>
162        public CvMat(IntPtr ptr)
163            : this(ptr, true)
164        {
165        }
166        /// <summary>
167        /// ポインタと自動解放の可否を指定して初期化
168        /// </summary>
169        /// <param name="ptr"></param>
170        /// <param name="isEnabledDispose"></param>
171        internal CvMat(IntPtr ptr, bool isEnabledDispose)
172            : base(isEnabledDispose)
173        {
174            this.ptr = ptr;
175            this.data = new Extern.WCvMat(ptr);
176            base.NotifyMemoryPressure(SizeOf);
177        }
178        /// <summary>
179        /// sizeof(CvMat)の分のメモリの割り当てだけ行って初期化
180        /// </summary>
181        public CvMat()
182            : this(true)
183        {
184        }
185        /// <summary>
186        /// sizeof(CvMat)の分のメモリの割り当てだけ行って、GC禁止設定で初期化
187        /// </summary>
188        internal CvMat(bool isEnabledDispose)
189            : base(isEnabledDispose)
190        {
191            this.ptr = base.AllocMemory(SizeOf);
192            this.data = new Extern.WCvMat(ptr);
193            base.NotifyMemoryPressure(SizeOf);
194        }
195
196        #region staticメソッドによる初期化
197        #region 1次元配列から
198        /// <summary>
199        /// double[]からCvMatを初期化して返す. F64C1型として生成する。
200        /// </summary>
201        /// <param name="data"></param>
202        /// <returns>CvMat</returns>
203        public static CvMat FromArray(double[] data)
204        {
205            if (data == null)
206            {
207                throw new ArgumentNullException("data");
208            }
209            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F64C1, data);
210        }
211        /// <summary>
212        /// float[]からCvMatを初期化して返す. F32C1型として生成する。
213        /// </summary>
214        /// <param name="data"></param>
215        /// <returns>CvMat</returns>
216        public static CvMat FromArray(float[] data)
217        {
218            if (data == null)
219            {
220                throw new ArgumentNullException("data");
221            }
222            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F32C1, data);
223        }
224        /// <summary>
225        /// int[]からCvMatを初期化して返す. S32C1型として生成する。
226        /// </summary>
227        /// <param name="data"></param>
228        /// <returns>CvMat</returns>
229        public static CvMat FromArray(int[] data)
230        {
231            if (data == null)
232            {
233                throw new ArgumentNullException("data");
234            }
235            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S32C1, data);
236        }
237        /// <summary>
238        /// short[]からCvMatを初期化して返す. S16C1型として生成する。
239        /// </summary>
240        /// <param name="data"></param>
241        /// <returns>CvMat</returns>
242        public static CvMat FromArray(short[] data)
243        {
244            if (data == null)
245            {
246                throw new ArgumentNullException("data");
247            }
248            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S16C1, data);
249        }
250        /// <summary>
251        /// byte[]からCvMatを初期化して返す. U8C1型として生成する。
252        /// </summary>
253        /// <param name="data"></param>
254        /// <returns>CvMat</returns>
255        public static CvMat FromArray(byte[] data)
256        {
257            if (data == null)
258            {
259                throw new ArgumentNullException("data");
260            }
261            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.U8C1, data);
262        }
263        /// <summary>
264        /// T[]からCvMatを初期化して返す
265        /// </summary>
266        /// <typeparam name="T"></typeparam>
267        /// <param name="data"></param>
268        /// <param name="type"></param>
269        /// <returns></returns>
270        public static CvMat FromArray<T>(T[] data, MatrixType type) where T : struct
271        {
272            if (data == null)
273            {
274                throw new ArgumentNullException("data");
275            }
276            return new CvMat(data.GetLength(0), data.GetLength(1), type, data);
277        }
278        #endregion
279        #region 2次元配列から
280        /// <summary>
281        /// 2次元のRectangular Arrayを1次元配列に変換する
282        /// </summary>
283        /// <typeparam name="T"></typeparam>
284        /// <param name="array"></param>
285        /// <returns></returns>
286        private static T[] ToLinearArtay<T>(T[,] array)
287        {
288            int row = array.GetLength(0);
289            int col = array.GetLength(1);
290            T[] result = new T[row * col];
291            for (int r = 0; r < row; r++)
292            {
293                for (int c = 0; c < col; c++)
294                {
295                    result[r * col + c] = array[r, c];
296                }
297            }
298            return result;
299        }
300        /// <summary>
301        /// double[,]からCvMatを初期化して返す. F64C1型として生成する。
302        /// </summary>
303        /// <param name="data"></param>
304        /// <returns>CvMat</returns>
305        public static CvMat FromArray(double[,] data)
306        {
307            if (data == null)
308            {
309                throw new ArgumentNullException("data");
310            }
311            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F64C1, data);
312        }
313        /// <summary>
314        /// float[,]からCvMatを初期化して返す. F32C1型として生成する。
315        /// </summary>
316        /// <param name="data"></param>
317        /// <returns>CvMat</returns>
318        public static CvMat FromArray(float[,] data)
319        {
320            if (data == null)
321            {
322                throw new ArgumentNullException("data");
323            }
324            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F32C1, data);
325        }
326        /// <summary>
327        /// int[,]からCvMatを初期化して返す. S32C1型として生成する。
328        /// </summary>
329        /// <param name="data"></param>
330        /// <returns>CvMat</returns>
331        public static CvMat FromArray(int[,] data)
332        {
333            if (data == null)
334            {
335                throw new ArgumentNullException("data");
336            }
337            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S32C1, data);
338        }
339        /// <summary>
340        /// short[,]からCvMatを初期化して返す. S16C1型として生成する。
341        /// </summary>
342        /// <param name="data"></param>
343        /// <returns>CvMat</returns>
344        public static CvMat FromArray(short[,] data)
345        {
346            if (data == null)
347            {
348                throw new ArgumentNullException("data");
349            }
350            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S16C1, data);
351        }
352        /// <summary>
353        /// byte[,]からCvMatを初期化して返す. U8C1型として生成する。
354        /// </summary>
355        /// <param name="data"></param>
356        /// <returns>CvMat</returns>
357        public static CvMat FromArray(byte[,] data)
358        {
359            if (data == null)
360            {
361                throw new ArgumentNullException("data");
362            }
363            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.U8C1, data);
364        }
365        /// <summary>
366        /// T[,]からCvMatを初期化して返す. 
367        /// </summary>
368        /// <param name="data"></param>
369        /// <param name="type"></param>
370        /// <returns>CvMat</returns>
371        public static CvMat FromArray<T>(T[,] data, MatrixType type) where T : struct
372        {
373            if (data == null)
374            {
375                throw new ArgumentNullException("data");
376            }
377            return new CvMat(data.GetLength(0), data.GetLength(1), type, data);
378        }
379        #endregion
380        #region ファイルから
381#if LANG_JP
382        /// <summary>
383        /// 指定されたファイルから画像を読み込み,その画像の参照をCvMat形式で返す
384        /// </summary>
385        /// <param name="filename">ファイル名</param>
386        /// <returns>画像への参照</returns>
387#else
388        /// <summary>
389        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat.
390        /// </summary>
391        /// <param name="filename">Name of file to be loaded. </param>
392        /// <returns>the reference to the loaded image. </returns>
393#endif
394        public static CvMat FromFile(string filename)
395        {
396            return Cv.LoadImageM(filename);
397        }
398#if LANG_JP
399        /// <summary>
400        /// 指定されたファイルから画像を読み込み,その画像の参照をCvMat形式で返す
401        /// </summary>
402        /// <param name="filename">ファイル名</param>
403        /// <param name="flags">読み込む画像がカラー/グレースケールのどちらか,とビット深度を指定する</param>
404        /// <returns>画像への参照</returns>
405#else
406        /// <summary>
407        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat.
408        /// </summary>
409        /// <param name="filename">Name of file to be loaded. </param>
410        /// <param name="flags">Specifies colorness and Depth of the loaded image.</param>
411        /// <returns>the reference to the loaded image. </returns>
412#endif
413        public static CvMat LoadImageM(string filename, LoadMode flags)
414        {
415            return Cv.LoadImageM(filename, flags);
416        }
417        #endregion
418        #region OpenCVのメソッド
419        /// <summary>
420        /// 3点とそれぞれに対応する点からアフィン変換を計算する (2 x 3 のCV_32FC1型) [cvGetAffineTransform相当].
421        /// おそらくoutで出てくる行列と関数の返り値は同じなので、out引数の方を省いたものである.
422        /// (x'i,y'i)T=map_matrix•(xi,yi,1)T,
423        /// ここで dst(i)=(x'i,y'i), src(i)=(xi,yi), i=0..2.
424        /// </summary>
425        /// <param name="src">入力(変換前)画像内に存在する三角形の3つの頂点座標を格納した配列</param>
426        /// <param name="dst">出力(変換後)画像内に存在するsrcに対応した三角形の3つの頂点座標を格納した配列</param>
427        /// <returns>求められた 2×3のアフィン変換行列</returns>
428        public static CvMat AffineTransform(CvPoint2D32f[] src, CvPoint2D32f[] dst)
429        {
430            return Cv.GetAffineTransform(src, dst);
431        }
432        /// <summary>
433        /// 4点とそれぞれに対応する点を用いて透視変換行列を求める (3 x 3 のCV_32FC1型) [cvGetPerspectiveTransform相当].
434        /// おそらくoutで出てくる行列と関数の返り値は同じなので、out引数の方を省いたものである.
435        /// (ti•x'i,ti•y'i,ti)T = map_matrix•(xi,yi,1)T
436        /// ここで dst(i) = (x'i,y'i),  src(i) = (xi,yi), i=0..3.
437        /// </summary>
438        /// <param name="src">入力画像中の矩形の4頂点の座標</param>
439        /// <param name="dst">出力画像中の対応する矩形の4頂点の座標</param>
440        /// <returns>求められた 3×3の射影変換行列</returns>
441        public static CvMat PerspectiveTransform(CvPoint2D32f[] src, CvPoint2D32f[] dst)
442        {
443            return Cv.GetPerspectiveTransform(src, dst);
444        }
445        /// <summary>
446        /// 単位行列を生成して返す
447        /// </summary>
448        /// <param name="rows">行列の行数</param>
449        /// <param name="cols">行列の列数</param>
450        /// <param name="type">行列要素の種類</param>
451        public static CvMat Identity(int rows, int cols, MatrixType type)
452        {
453            return Identity(rows, cols, type, CvScalar.RealScalar(1));
454        }
455        /// <summary>
456        /// 単位行列を生成して返す
457        /// </summary>
458        /// <param name="rows">行列の行数</param>
459        /// <param name="cols">行列の列数</param>
460        /// <param name="type">行列要素の種類</param>
461        /// <param name="value">対角成分の値</param>
462        public static CvMat Identity(int rows, int cols, MatrixType type, CvScalar value)
463        {
464            IntPtr ptr = CvDll.cvCreateMatHeader(rows, cols, type);
465            CvDll.cvCreateData(ptr);
466            CvDll.cvSetIdentity(ptr, value);
467            return new CvMat(ptr);
468        }
469        /// <summary>
470        /// 2次元回転のアフィン行列を計算する (2 x 3 のCV_32FC1型)  (cv2DRotationMatrix相当).
471        /// </summary>
472        /// <param name="center">入力画像内の回転中心 </param>
473        /// <param name="angle">度(degree)単位の回転角度.正の値は反時計方向の回転を意味する(座標原点は左上にあると仮定).</param>
474        /// <param name="scale">等方性スケーリング係数(x,y方向とも同じ係数 scale を使う) </param>
475        /// <returns>2x3の2次元回転のアフィン行列</returns>
476        public static CvMat RotationMatrix(CvPoint2D32f center, double angle, double scale)
477        {
478            return Cv._2DRotationMatrix(center, angle, scale);
479        }
480        #endregion
481        #endregion
482
483#if LANG_JP
484        /// <summary>
485        /// 行列を解放する
486        /// </summary>
487#else
488        /// <summary>
489        /// Deallocates matrix.
490        /// </summary>
491#endif
492        public override void Dispose()
493        {
494            if (IsEnabledDispose && !IsDisposed)
495            {
496                CvDll.cvReleaseMat(ref ptr);
497            }
498            base.Dispose();
499        }
500        #endregion
501
502
503        #region Properties
504        /// <summary>
505        /// sizeof(CvMat)
506        /// </summary>
507        public const Int32 SizeOf = Extern.WCvMat.SizeOf;
508        /// <summary>
509        /// Native pointer (CvMat*)
510        /// </summary>
511        public override IntPtr CvPtr
512        {
513            get { return ptr; }
514        }
515
516#if LANG_JP
517        /// <summary>
518                /// CvMat シグネチャ (CV_MAT_MAGIC_VAL).要素の型とフラグ
519                /// </summary>
520#else
521        /// <summary>
522        /// CvMat signature (CV_MAT_MAGIC_VAL), element type and flags
523        /// </summary>
524#endif
525        public int Type
526        {
527            get { return data.type; }
528        }
529#if LANG_JP
530                /// <summary>
531                /// 全行のバイト長
532                /// </summary>
533#else
534        /// <summary>
535        /// Full row length in bytes
536        /// </summary>
537#endif
538        public int Step
539        {
540            get { return data.step; }
541        }
542
543        #region 行列データ
544#if LANG_JP
545        /// <summary>
546                /// 行列データへのポインタ.
547                /// 実際に格納しているデータ型に応じて適宜byte*やdouble*等にキャストして利用する。
548        /// </summary>
549#else
550        /// <summary>
551        /// Data pointer
552        /// </summary>
553#endif
554        public IntPtr Data
555        {
556            get { return data.data; }
557        }
558#if LANG_JP
559        /// <summary>
560                /// 行列データへのByte型ポインタ.
561                /// </summary>
562#else
563        /// <summary>
564        /// Data pointer as byte*
565        /// </summary>
566#endif
567        public unsafe byte* DataByte
568        {
569            get { return data.data_ptr; }
570        }
571#if LANG_JP
572                /// <summary>
573                /// 行列データへのInt16(short)型ポインタ.
574        /// </summary>
575#else
576        /// <summary>
577        /// Data pointer as short*
578        /// </summary>
579#endif
580        public unsafe short* DataInt16
581        {
582            get { return data.data_s; }
583        }
584#if LANG_JP
585                /// <summary>
586                /// 行列データへのInt32(int)型ポインタ.
587        /// </summary>
588#else
589        /// <summary>
590        /// Data pointer as int*
591        /// </summary>
592#endif
593        public unsafe int* DataInt32
594        {
595            get { return data.data_i; }
596        }
597#if LANG_JP
598                /// <summary>
599                /// 行列データへのSingle(float)型ポインタ.
600        /// </summary>
601#else
602        /// <summary>
603        /// Data pointer as float*
604        /// </summary>
605#endif
606        public unsafe float* DataSingle
607        {
608            get { return data.data_fl; }
609        }
610#if LANG_JP
611                /// <summary>
612                /// 行列データへのDouble型ポインタ.
613        /// </summary>
614#else
615        /// <summary>
616        /// Data pointer as double*
617        /// </summary>
618#endif
619        public unsafe double* DataDouble
620        {
621            get { return data.data_db; }
622        }
623#if LANG_JP
624        /// <summary>
625                /// 行列データへのByte型ポインタ. 配列のようにアクセス可能.
626        /// </summary>
627#else
628        /// <summary>
629        /// Data pointer(byte*) which can be accessed without unsafe code.
630        /// </summary>
631#endif
632        public PointerAccessor.Byte1 DataArrayByte
633        {
634            get
635            {
636                if (dataArrayByte == null)
637                {
638                    unsafe
639                    {
640                        dataArrayByte = new PointerAccessor.Byte1(data.data_ptr);
641                    }
642                }
643                return dataArrayByte;
644            }
645        }
646#if LANG_JP
647                /// <summary>
648                /// 行列データへのInt16(short)型ポインタ. 配列のようにアクセス可能.
649        /// </summary>
650#else
651        /// <summary>
652        /// Data pointer(short*) which can be accessed without unsafe code.
653        /// </summary>
654#endif
655        public PointerAccessor.Short1 DataArrayShort
656        {
657            get
658            {
659                if (dataArrayShort == null)
660                {
661                    unsafe
662                    {
663                        dataArrayShort = new PointerAccessor.Short1(data.data_s);
664                    }
665                }
666                return dataArrayShort;
667            }
668        }
669#if LANG_JP
670                /// <summary>
671                /// 行列データへのInt32(int)型ポインタ. 配列のようにアクセス可能.
672        /// </summary>
673#else
674        /// <summary>
675        /// Data pointer(int*) which can be accessed without unsafe code.
676        /// </summary>
677#endif
678        public PointerAccessor.Int1 DataArrayInt
679        {
680            get
681            {
682                if (dataArrayInt == null)
683                {
684                    unsafe
685                    {
686                        dataArrayInt = new PointerAccessor.Int1(data.data_i);
687                    }
688                }
689                return dataArrayInt;
690            }
691        }
692#if LANG_JP
693                /// <summary>
694                /// 行列データへのSingle(float)型ポインタ. 配列のようにアクセス可能.
695        /// </summary>
696#else
697        /// <summary>
698        /// Data pointer(float*) which can be accessed without unsafe code.
699        /// </summary>
700#endif
701        public PointerAccessor.Float1 DataArrayFloat
702        {
703            get
704            {
705                if (dataArrayFloat == null)
706                {
707                    unsafe
708                    {
709                        dataArrayFloat = new PointerAccessor.Float1(data.data_fl);
710                    }
711                }
712                return dataArrayFloat;
713            }
714        }
715#if LANG_JP
716                /// <summary>
717                /// 行列データへのDouble型ポインタ. 配列のようにアクセス可能.
718        /// </summary>
719#else
720        /// <summary>
721        /// Data pointer(double*) which can be accessed without unsafe code.
722        /// </summary>
723#endif
724        public PointerAccessor.Double1 DataArrayDouble
725        {
726            get
727            {
728                if (dataArrayDouble == null)
729                {
730                    unsafe
731                    {
732                        dataArrayDouble = new PointerAccessor.Double1(data.data_db);
733                    }
734                }
735                return dataArrayDouble;
736            }
737        }
738        #endregion
739
740#if LANG_JP
741        /// <summary>
742                /// 行列の列数
743                /// </summary>
744#else
745        /// <summary>
746        /// number of columns
747        /// </summary>
748#endif
749        public int Cols
750        {
751            get { return data.cols; }
752        }
753#if LANG_JP
754                /// <summary>
755                /// 行列の列数
756                /// </summary>
757#else
758        /// <summary>
759        /// number of columns
760        /// </summary>
761#endif
762        public int Height
763        {
764            get { return data.height; }
765        }
766#if LANG_JP
767                /// <summary>
768                /// 行列の行数
769                /// </summary>
770#else
771        /// <summary>
772        /// number of rows
773        /// </summary>
774#endif
775        public int Rows
776        {
777            get { return data.rows; }
778        }
779#if LANG_JP
780                /// <summary>
781                /// 行列の行数
782                /// </summary>
783#else
784        /// <summary>
785        /// number of rows
786        /// </summary>
787#endif
788        public int Width
789        {
790            get { return data.width; }
791        }
792#if LANG_JP
793        /// <summary>
794        /// 配列の次元数を取得する (2固定)
795        /// </summary>
796#else
797        /// <summary>
798        /// Number of dimensions (=2)
799        /// </summary>
800#endif
801        public override Int32 Dims
802        {
803            get { return 2; }
804        }
805
806#if LANG_JP
807        /// <summary>
808                /// 特定の配列要素を取得・設定する (cvmGet, cvmSet相当).
809                /// </summary>
810                /// <param name="row">要素インデックスの,0を基準とした第1成分.</param>
811                /// <param name="col">要素インデックスの,0を基準とした第2成分.</param>
812        /// <returns>指定した要素の値</returns>
813#else
814        /// <summary>
815        /// Get/Set the particular element of single-channel floating-point matrix (cvmGet/cvmSet)
816        /// </summary>
817        /// <param name="row">The zero-based index of row. </param>
818        /// <param name="col">The zero-based index of column. </param>
819        /// <returns>the particular element's value</returns>
820#endif
821        new public double this[int row, int col]
822        {
823            get
824            {
825                return CvInline.cvmGet(ptr, row, col);
826            }
827            set
828            {
829                CvInline.cvmSet(ptr, row, col, value);
830            }
831        }
832        #endregion
833
834
835        #region Operators
836        /// <summary>
837        /// 行列の単項+演算子
838        /// </summary>
839        /// <param name="a">行列</param>
840        /// <returns></returns>
841        public static CvMat operator +(CvMat a)
842        {
843            if (a == null)
844            {
845                throw new ArgumentNullException("a");
846            }
847            return a.Clone();
848        }
849        /// <summary>
850        /// 行列の単項-演算子
851        /// </summary>
852        /// <param name="a">行列</param>
853        /// <returns></returns>
854        public static CvMat operator -(CvMat a)
855        {
856            if (a == null)
857            {
858                throw new ArgumentNullException("a");
859            }
860            CvMat result = a.Clone();
861            Cv.AddWeighted(a, -1, a, 0, 0, result);
862            return result;
863        }
864        /// <summary>
865        /// 行列の単項not演算子
866        /// </summary>
867        /// <param name="a">行列</param>
868        /// <returns></returns>
869        public static CvMat operator ~(CvMat a)
870        {
871            if (a == null)
872            {
873                throw new ArgumentNullException("a");
874            }
875            CvMat result = a.Clone();
876            Cv.Not(a, result);
877            return result;
878        }
879        /// <summary>
880        /// 行列と行列の加算演算子。cvAddにより加算する。
881        /// </summary>
882        /// <param name="a">行列</param>
883        /// <param name="b">行列</param>
884        /// <returns></returns>
885        public static CvMat operator +(CvMat a, CvMat b)
886        {
887            if (a == null)
888                throw new ArgumentNullException("a");
889            if (b == null)
890                throw new ArgumentNullException("b");
891            CvMat result = a.Clone();
892            Cv.Add(a, b, result);
893            return result;
894        }
895        /// <summary>
896        /// 行列とスカラーの加算演算子。cvAddSにより加算する。
897        /// </summary>
898        /// <param name="a">行列</param>
899        /// <param name="b">スカラー</param>
900        /// <returns></returns>
901        public static CvMat operator +(CvMat a, CvScalar b)
902        {
903            if (a == null)
904            {
905                throw new ArgumentNullException("a");
906            }
907            CvMat result = a.Clone();
908            Cv.AddS(a, b, result);
909            return result;
910        }
911        /// <summary>
912        /// 行列と行列の減算演算子。cvSubにより減算する。
913        /// </summary>
914        /// <param name="a">行列</param>
915        /// <param name="b">行列</param>
916        /// <returns></returns>
917        public static CvMat operator -(CvMat a, CvMat b)
918        {
919            if (a == null)
920                throw new ArgumentNullException("a");
921            if (b == null)
922                throw new ArgumentNullException("b");
923            CvMat result = a.Clone();
924            Cv.Sub(a, b, result);
925            return result;
926        }
927        /// <summary>
928        /// 行列とスカラーの減算演算子。cvSubSにより加算する。
929        /// </summary>
930        /// <param name="a">行列</param>
931        /// <param name="b">スカラー</param>
932        /// <returns></returns>
933        public static CvMat operator -(CvMat a, CvScalar b)
934        {
935            if (a == null)
936            {
937                throw new ArgumentNullException("a");
938            }
939            CvMat result = a.Clone();
940            Cv.SubS(a, b, result);
941            return result;
942        }
943        /// <summary>
944        /// 行列と行列の乗算演算子。cvMatMulにより乗算する。
945        /// </summary>
946        /// <param name="a">行列</param>
947        /// <param name="b">行列</param>
948        /// <returns></returns>
949        public static CvMat operator *(CvMat a, CvMat b)
950        {
951            if (a == null)
952                throw new ArgumentNullException("a");
953            if (b == null)
954                throw new ArgumentNullException("b");
955            CvMat result = a.Clone();
956            Cv.MatMul(a, b, result);
957            return result;
958        }
959        /// <summary>
960        /// 行列とスカラーの乗算演算子。aの要素ごとにbをかけた結果をcvAddWeightedにより求める。
961        /// </summary>
962        /// <param name="a">行列</param>
963        /// <param name="b">スカラー</param>
964        /// <returns></returns>
965        public static CvMat operator *(CvMat a, Double b)
966        {
967            if (a == null)
968            {
969                throw new ArgumentNullException("a");
970            }
971            CvMat result = a.Clone();
972            Cv.AddWeighted(a, b, a, 0, 0, result);
973            return result;
974        }
975        /// <summary>
976        /// 行列とスカラーの除算演算子。aの要素ごとにbで割った結果をcvAddWeightedにより求める。
977        /// </summary>
978        /// <param name="a">行列</param>
979        /// <param name="b">スカラー</param>
980        /// <returns></returns>
981        public static CvMat operator /(CvMat a, double b)
982        {
983            if (a == null)
984            {
985                throw new ArgumentNullException("a");
986            }
987            if (b == 0)
988            {
989                throw new DivideByZeroException();
990            }
991            CvMat result = a.Clone();
992            Cv.AddWeighted(a, 1.0 / b, a, 0, 0, result);
993            return result;
994        }
995        /// <summary>
996        /// 行列と行列のand演算子。cvAndにより求める。
997        /// </summary>
998        /// <param name="a">行列</param>
999        /// <param name="b">行列</param>
1000        /// <returns></returns>
1001        public static CvMat operator &(CvMat a, CvMat b)
1002        {
1003            if (a == null)
1004                throw new ArgumentNullException("a");
1005            if (b == null)
1006                throw new ArgumentNullException("b");
1007            CvMat result = a.Clone();
1008            Cv.And(a, b, result);
1009            return result;
1010        }
1011        /// <summary>
1012        /// 行列とスカラーのand演算子。cvAndSにより求める。
1013        /// </summary>
1014        /// <param name="a">行列</param>
1015        /// <param name="b">スカラー</param>
1016        /// <returns></returns>
1017        public static CvMat operator &(CvMat a, CvScalar b)
1018        {
1019            if (a == null)
1020            {
1021                throw new ArgumentNullException("a");
1022            }
1023            CvMat result = a.Clone();
1024            Cv.AndS(a, b, result);
1025            return result;
1026        }
1027        /// <summary>
1028        /// 行列と行列のor演算子。cvOrにより求める。
1029        /// </summary>
1030        /// <param name="a">行列</param>
1031        /// <param name="b">行列</param>
1032        /// <returns></returns>
1033        public static CvMat operator |(CvMat a, CvMat b)
1034        {
1035            if (a == null)
1036                throw new ArgumentNullException("a");
1037            if (b == null)
1038                throw new ArgumentNullException("b");
1039            CvMat result = a.Clone();
1040            Cv.Or(a, b, result);
1041            return result;
1042        }
1043        /// <summary>
1044        /// 行列とスカラーのor演算子。cvOrSにより求める。
1045        /// </summary>
1046        /// <param name="a">行列</param>
1047        /// <param name="b">スカラー</param>
1048        /// <returns></returns>
1049        public static CvMat operator |(CvMat a, CvScalar b)
1050        {
1051            if (a == null)
1052            {
1053                throw new ArgumentNullException("a");
1054            }
1055            CvMat result = a.Clone();
1056            Cv.OrS(a, b, result);
1057            return result;
1058        }
1059        /// <summary>
1060        /// 行列と行列のxor演算子。cvXorにより求める。
1061        /// </summary>
1062        /// <param name="a">行列</param>
1063        /// <param name="b">行列</param>
1064        /// <returns></returns>
1065        public static CvMat operator ^(CvMat a, CvMat b)
1066        {
1067            if (a == null)
1068                throw new ArgumentNullException("a");
1069            if (b == null)
1070                throw new ArgumentNullException("b");
1071            CvMat result = a.Clone();
1072            Cv.Xor(a, b, result);
1073            return result;
1074        }
1075        /// <summary>
1076        /// 行列とスカラーのxor演算子。cvXorSにより求める。
1077        /// </summary>
1078        /// <param name="a">行列</param>
1079        /// <param name="b">スカラー</param>
1080        /// <returns></returns>
1081        public static CvMat operator ^(CvMat a, CvScalar b)
1082        {
1083            if (a == null)
1084            {
1085                throw new ArgumentNullException("a");
1086            }
1087            CvMat result = a.Clone();
1088            Cv.XorS(a, b, result);
1089            return result;
1090        }
1091        #endregion
1092
1093
1094        #region Methods
1095        #region Clone
1096#if LANG_JP
1097        /// <summary>
1098        /// 行列のコピーを作成する (cvCloneMat)
1099        /// </summary>
1100        /// <returns>コピーされた行列</returns>
1101#else
1102        /// <summary>
1103        /// Creates matrix copy (cvCloneMat)
1104        /// </summary>
1105        /// <returns>a copy of input array</returns>
1106#endif
1107        public CvMat Clone()
1108        {
1109            return Cv.CloneMat(this);
1110        }
1111        object ICloneable.Clone()
1112        {
1113            return Clone();
1114        }
1115        #endregion
1116        #endregion
1117
1118
1119        /// <summary>
1120        /// 文字列形式を返す. 1チャンネルの場合のみに対応している.
1121        /// </summary>
1122        /// <returns>文字列形式</returns>
1123        public override string ToString()
1124        {
1125            if (ElemChannels == 1)
1126            {
1127                StringBuilder sb = new StringBuilder();
1128                sb.AppendFormat("CvMat(Rows={0}, Cols={1})\n", Rows, Cols);
1129                for (int i = 0; i < Rows; i++)
1130                {
1131                    for (int j = 0; j < Cols; j++)
1132                    {
1133                        sb.Append(Cv.mGet(this, i, j));
1134                        sb.Append("\t");
1135                    }
1136                    sb.AppendLine();
1137                }
1138                return sb.ToString();
1139            }
1140            return base.ToString();
1141        }
1142
1143    }
1144}
Note: See TracBrowser for help on using the browser.