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

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using KwsmLab.OpenCvSharp.Extern;

namespace KwsmLab.OpenCvSharp
{
#if LANG_JP
    /// <summary>
    /// 多重行列
    /// </summary>
#else
    /// <summary>
    /// Multi-channel matrix
    /// </summary>
#endif
    public class CvMat : CvArr, ICloneable
    {
        #region Variables
        /// <summary>
        /// C++/CLI側でポインタにアクセスするオブジェクト
        /// </summary>
        private Extern.WCvMat data;
        /// <summary>
        /// データポインタ
        /// </summary>
        private IntPtr ptr;

        /// <summary>
        /// 
        /// </summary>
        private PointerAccessor.Byte1 dataArrayByte;
        /// <summary>
        /// 
        /// </summary>
        private PointerAccessor.Short1 dataArrayShort;
        /// <summary>
        /// 
        /// </summary>
        private PointerAccessor.Int1 dataArrayInt;
        /// <summary>
        /// 
        /// </summary>
        private PointerAccessor.Float1 dataArrayFloat;
        /// <summary>
        /// 
        /// </summary>
        private PointerAccessor.Double1 dataArrayDouble;
        #endregion


        #region Initialization and Disposal
#if LANG_JP
        /// <summary>
        /// 新たな行列とその内部データのためのヘッダを確保する
        /// </summary>
        /// <param name="rows">行列の行数</param>
        /// <param name="cols">行列の列数</param>
        /// <param name="type">行列要素の種類</param>
        /// <returns>行列</returns>
#else
        /// <summary>
        /// Allocates header for the new matrix and underlying data, and returns a pointer to the created matrix.
        /// </summary>
        /// <param name="rows">Number of rows in the matrix. </param>
        /// <param name="cols">Number of columns in the matrix. </param>
        /// <param name="type">Type of the matrix elements.</param>
        /// <returns></returns>
#endif
        public CvMat(int rows, int cols, MatrixType type)
        {
            this.ptr = CvDll.cvCreateMat(rows, cols, type);
            if (this.ptr == IntPtr.Zero)
            {
                throw new OpenCvSharpException("Failed to create CvMat");
            }
            this.data = new Extern.WCvMat(this.ptr);
            NotifyMemoryPressure(SizeOf);
        }
#if LANG_JP
        /// <summary>
        /// 新たな行列とその内部データのためのヘッダを確保し、内部データに指定した配列を指定する
        /// </summary>
        /// <param name="rows">行列の行数</param>
        /// <param name="cols">行列の列数</param>
        /// <param name="type">行列要素の種類</param>
        /// <param name="elements">行列要素とする配列. blittableな型の配列でなければならない(intやCvPointなど)</param>
        /// <returns>行列</returns>
#else
        /// <summary>
        /// Allocates header for the new matrix and underlying data, and returns a pointer to the created matrix.
        /// </summary>
        /// <param name="rows">Number of rows in the matrix. </param>
        /// <param name="cols">Number of columns in the matrix. </param>
        /// <param name="type">Type of the matrix elements.</param>
        /// <param name="elements">Data of elements. The type of the array must be blittable.</param>
        /// <returns></returns>
#endif
        public CvMat(int rows, int cols, MatrixType type, Array elements)
            : this(rows, cols, type)
        {
            GCHandle gch = base.AllocGCHandle(elements);
            CvDll.cvSetData(CvPtr, gch.AddrOfPinnedObject(), Cv.AUTOSTEP);
        }

#if LANG_JP
        /// <summary>
        /// 指定されたファイルから画像を読み込んで初期化
        /// </summary>
        /// <param name="filename">ファイル名</param>
#else
        /// <summary>
        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat. 
        /// </summary>
        /// <param name="filename">Name of file to be loaded. </param>
        /// <returns>the reference to the loaded image. </returns>
#endif
        public CvMat(string filename)
            : this(filename, LoadMode.Color)
        {
        }
#if LANG_JP
        /// <summary>
        /// 指定されたファイルから画像を読み込んで初期化
        /// </summary>
        /// <param name="filename">ファイル名</param>
        /// <param name="flags">読み込む画像がカラー/グレースケールのどちらか，とビット深度を指定する</param>
#else
        /// <summary>
        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat. 
        /// </summary>
        /// <param name="filename">Name of file to be loaded. </param>
        /// <param name="flags">Specifies colorness and Depth of the loaded image.</param>
        /// <returns>the reference to the loaded image. </returns>
#endif
        public CvMat(string filename, LoadMode flags)
        {
            if (string.IsNullOrEmpty(filename))
            {
                throw new ArgumentNullException("filename");
            }
            if (!File.Exists(filename))
            {
                throw new FileNotFoundException("", filename);
            }
            this.ptr = CvDll.cvLoadImageM(filename, flags);
            if (this.ptr == IntPtr.Zero)
            {
                throw new OpenCvSharpException("Failed to create CvMat");
            }
            this.data = new Extern.WCvMat(ptr);
            base.NotifyMemoryPressure(SizeOf);
        }

        /// <summary>
        /// ポインタから初期化
        /// </summary>
        /// <param name="ptr"></param>
        public CvMat(IntPtr ptr)
            : this(ptr, true)
        {
        }
        /// <summary>
        /// ポインタと自動解放の可否を指定して初期化
        /// </summary>
        /// <param name="ptr"></param>
        /// <param name="isEnabledDispose"></param>
        internal CvMat(IntPtr ptr, bool isEnabledDispose)
            : base(isEnabledDispose)
        {
            this.ptr = ptr;
            this.data = new Extern.WCvMat(ptr);
            base.NotifyMemoryPressure(SizeOf);
        }
        /// <summary>
        /// sizeof(CvMat)の分のメモリの割り当てだけ行って初期化
        /// </summary>
        public CvMat()
            : this(true)
        {
        }
        /// <summary>
        /// sizeof(CvMat)の分のメモリの割り当てだけ行って、GC禁止設定で初期化
        /// </summary>
        internal CvMat(bool isEnabledDispose)
            : base(isEnabledDispose)
        {
            this.ptr = base.AllocMemory(SizeOf);
            this.data = new Extern.WCvMat(ptr);
            base.NotifyMemoryPressure(SizeOf);
        }

        #region staticメソッドによる初期化
        #region 1次元配列から
        /// <summary>
        /// double[]からCvMatを初期化して返す. F64C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(double[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F64C1, data);
        }
        /// <summary>
        /// float[]からCvMatを初期化して返す. F32C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(float[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F32C1, data);
        }
        /// <summary>
        /// int[]からCvMatを初期化して返す. S32C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(int[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S32C1, data);
        }
        /// <summary>
        /// short[]からCvMatを初期化して返す. S16C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(short[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S16C1, data);
        }
        /// <summary>
        /// byte[]からCvMatを初期化して返す. U8C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(byte[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.U8C1, data);
        }
        /// <summary>
        /// T[]からCvMatを初期化して返す
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static CvMat FromArray<T>(T[] data, MatrixType type) where T : struct
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), type, data);
        }
        #endregion
        #region 2次元配列から
        /// <summary>
        /// 2次元のRectangular Arrayを1次元配列に変換する
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <returns></returns>
        private static T[] ToLinearArtay<T>(T[,] array)
        {
            int row = array.GetLength(0);
            int col = array.GetLength(1);
            T[] result = new T[row * col];
            for (int r = 0; r < row; r++)
            {
                for (int c = 0; c < col; c++)
                {
                    result[r * col + c] = array[r, c];
                }
            }
            return result;
        }
        /// <summary>
        /// double[,]からCvMatを初期化して返す. F64C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(double[,] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F64C1, data);
        }
        /// <summary>
        /// float[,]からCvMatを初期化して返す. F32C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(float[,] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.F32C1, data);
        }
        /// <summary>
        /// int[,]からCvMatを初期化して返す. S32C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(int[,] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S32C1, data);
        }
        /// <summary>
        /// short[,]からCvMatを初期化して返す. S16C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(short[,] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.S16C1, data);
        }
        /// <summary>
        /// byte[,]からCvMatを初期化して返す. U8C1型として生成する。 
        /// </summary>
        /// <param name="data"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray(byte[,] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), MatrixType.U8C1, data);
        }
        /// <summary>
        /// T[,]からCvMatを初期化して返す.  
        /// </summary>
        /// <param name="data"></param>
        /// <param name="type"></param>
        /// <returns>CvMat</returns>
        public static CvMat FromArray<T>(T[,] data, MatrixType type) where T : struct
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return new CvMat(data.GetLength(0), data.GetLength(1), type, data);
        }
        #endregion
        #region ファイルから
#if LANG_JP
        /// <summary>
        /// 指定されたファイルから画像を読み込み，その画像の参照をCvMat形式で返す
        /// </summary>
        /// <param name="filename">ファイル名</param>
        /// <returns>画像への参照</returns>
#else
        /// <summary>
        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat. 
        /// </summary>
        /// <param name="filename">Name of file to be loaded. </param>
        /// <returns>the reference to the loaded image. </returns>
#endif
        public static CvMat FromFile(string filename)
        {
            return Cv.LoadImageM(filename);
        }
#if LANG_JP
        /// <summary>
        /// 指定されたファイルから画像を読み込み，その画像の参照をCvMat形式で返す
        /// </summary>
        /// <param name="filename">ファイル名</param>
        /// <param name="flags">読み込む画像がカラー/グレースケールのどちらか，とビット深度を指定する</param>
        /// <returns>画像への参照</returns>
#else
        /// <summary>
        /// Loads an image from the specified file and returns the reference to the loaded image as CvMat. 
        /// </summary>
        /// <param name="filename">Name of file to be loaded. </param>
        /// <param name="flags">Specifies colorness and Depth of the loaded image.</param>
        /// <returns>the reference to the loaded image. </returns>
#endif
        public static CvMat LoadImageM(string filename, LoadMode flags)
        {
            return Cv.LoadImageM(filename, flags);
        }
        #endregion
        #region OpenCVのメソッド
        /// <summary>
        /// 3点とそれぞれに対応する点からアフィン変換を計算する (2 x 3 のCV_32FC1型) [cvGetAffineTransform相当]. 
        /// おそらくoutで出てくる行列と関数の返り値は同じなので、out引数の方を省いたものである.
        /// (x'i,y'i)T=map_matrix•(xi,yi,1)T, 
        /// ここで dst(i)=(x'i,y'i), src(i)=(xi,yi), i=0..2.
        /// </summary>
        /// <param name="src">入力（変換前）画像内に存在する三角形の3つの頂点座標を格納した配列</param>
        /// <param name="dst">出力（変換後）画像内に存在するsrcに対応した三角形の3つの頂点座標を格納した配列</param>
        /// <returns>求められた 2×3のアフィン変換行列</returns>
        public static CvMat AffineTransform(CvPoint2D32f[] src, CvPoint2D32f[] dst)
        {
            return Cv.GetAffineTransform(src, dst);
        }
        /// <summary>
        /// 4点とそれぞれに対応する点を用いて透視変換行列を求める (3 x 3 のCV_32FC1型) [cvGetPerspectiveTransform相当].
        /// おそらくoutで出てくる行列と関数の返り値は同じなので、out引数の方を省いたものである.
        /// (ti•x'i,ti•y'i,ti)T = map_matrix•(xi,yi,1)T
        /// ここで dst(i) = (x'i,y'i),  src(i) = (xi,yi), i=0..3.
        /// </summary>
        /// <param name="src">入力画像中の矩形の４頂点の座標</param>
        /// <param name="dst">出力画像中の対応する矩形の４頂点の座標</param>
        /// <returns>求められた 3×3の射影変換行列</returns>
        public static CvMat PerspectiveTransform(CvPoint2D32f[] src, CvPoint2D32f[] dst)
        {
            return Cv.GetPerspectiveTransform(src, dst);
        }
        /// <summary>
        /// 単位行列を生成して返す
        /// </summary>
        /// <param name="rows">行列の行数</param>
        /// <param name="cols">行列の列数</param>
        /// <param name="type">行列要素の種類</param>
        public static CvMat Identity(int rows, int cols, MatrixType type)
        {
            return Identity(rows, cols, type, CvScalar.RealScalar(1));
        }
        /// <summary>
        /// 単位行列を生成して返す
        /// </summary>
        /// <param name="rows">行列の行数</param>
        /// <param name="cols">行列の列数</param>
        /// <param name="type">行列要素の種類</param>
        /// <param name="value">対角成分の値</param>
        public static CvMat Identity(int rows, int cols, MatrixType type, CvScalar value)
        {
            IntPtr ptr = CvDll.cvCreateMatHeader(rows, cols, type);
            CvDll.cvCreateData(ptr);
            CvDll.cvSetIdentity(ptr, value);
            return new CvMat(ptr);
        }
        /// <summary>
        /// 2次元回転のアフィン行列を計算する (2 x 3 のCV_32FC1型)  (cv2DRotationMatrix相当).
        /// </summary>
        /// <param name="center">入力画像内の回転中心 </param>
        /// <param name="angle">度（degree）単位の回転角度．正の値は反時計方向の回転を意味する（座標原点は左上にあると仮定）．</param>
        /// <param name="scale">等方性スケーリング係数（x,y方向とも同じ係数 scale を使う） </param>
        /// <returns>2x3の2次元回転のアフィン行列</returns>
        public static CvMat RotationMatrix(CvPoint2D32f center, double angle, double scale)
        {
            return Cv._2DRotationMatrix(center, angle, scale);
        }
        #endregion
        #endregion

#if LANG_JP
        /// <summary>
        /// 行列を解放する
        /// </summary>
#else
        /// <summary>
        /// Deallocates matrix.
        /// </summary>
#endif
        public override void Dispose()
        {
            if (IsEnabledDispose && !IsDisposed)
            {
                CvDll.cvReleaseMat(ref ptr);
            }
            base.Dispose();
        }
        #endregion


        #region Properties
        /// <summary>
        /// sizeof(CvMat)
        /// </summary>
        public const Int32 SizeOf = Extern.WCvMat.SizeOf;
        /// <summary>
        /// Native pointer (CvMat*)
        /// </summary>
        public override IntPtr CvPtr
        {
            get { return ptr; }
        }

#if LANG_JP
        /// <summary>
                /// CvMat シグネチャ (CV_MAT_MAGIC_VAL)．要素の型とフラグ 
                /// </summary>
#else
        /// <summary>
        /// CvMat signature (CV_MAT_MAGIC_VAL), element type and flags
        /// </summary>
#endif
        public int Type
        {
            get { return data.type; }
        }
#if LANG_JP
                /// <summary>
                /// 全行のバイト長
                /// </summary>
#else
        /// <summary>
        /// Full row length in bytes
        /// </summary>
#endif
        public int Step
        {
            get { return data.step; }
        }

        #region 行列データ
#if LANG_JP
        /// <summary>
                /// 行列データへのポインタ.
                /// 実際に格納しているデータ型に応じて適宜byte*やdouble*等にキャストして利用する。
        /// </summary>
#else
        /// <summary>
        /// Data pointer
        /// </summary>
#endif
        public IntPtr Data
        {
            get { return data.data; }
        }
#if LANG_JP
        /// <summary>
                /// 行列データへのByte型ポインタ.
                /// </summary>
#else
        /// <summary>
        /// Data pointer as byte*
        /// </summary>
#endif
        public unsafe byte* DataByte
        {
            get { return data.data_ptr; }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのInt16(short)型ポインタ.
        /// </summary>
#else
        /// <summary>
        /// Data pointer as short*
        /// </summary>
#endif
        public unsafe short* DataInt16
        {
            get { return data.data_s; }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのInt32(int)型ポインタ.
        /// </summary>
#else
        /// <summary>
        /// Data pointer as int*
        /// </summary>
#endif
        public unsafe int* DataInt32
        {
            get { return data.data_i; }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのSingle(float)型ポインタ.
        /// </summary>
#else
        /// <summary>
        /// Data pointer as float*
        /// </summary>
#endif
        public unsafe float* DataSingle
        {
            get { return data.data_fl; }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのDouble型ポインタ.
        /// </summary>
#else
        /// <summary>
        /// Data pointer as double*
        /// </summary>
#endif
        public unsafe double* DataDouble
        {
            get { return data.data_db; }
        }
#if LANG_JP
        /// <summary>
                /// 行列データへのByte型ポインタ. 配列のようにアクセス可能.
        /// </summary>
#else
        /// <summary>
        /// Data pointer(byte*) which can be accessed without unsafe code.
        /// </summary>
#endif
        public PointerAccessor.Byte1 DataArrayByte
        {
            get
            {
                if (dataArrayByte == null)
                {
                    unsafe
                    {
                        dataArrayByte = new PointerAccessor.Byte1(data.data_ptr);
                    }
                }
                return dataArrayByte;
            }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのInt16(short)型ポインタ. 配列のようにアクセス可能.
        /// </summary>
#else
        /// <summary>
        /// Data pointer(short*) which can be accessed without unsafe code.
        /// </summary>
#endif
        public PointerAccessor.Short1 DataArrayShort
        {
            get
            {
                if (dataArrayShort == null)
                {
                    unsafe
                    {
                        dataArrayShort = new PointerAccessor.Short1(data.data_s);
                    }
                }
                return dataArrayShort;
            }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのInt32(int)型ポインタ. 配列のようにアクセス可能.
        /// </summary>
#else
        /// <summary>
        /// Data pointer(int*) which can be accessed without unsafe code.
        /// </summary>
#endif
        public PointerAccessor.Int1 DataArrayInt
        {
            get
            {
                if (dataArrayInt == null)
                {
                    unsafe
                    {
                        dataArrayInt = new PointerAccessor.Int1(data.data_i);
                    }
                }
                return dataArrayInt;
            }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのSingle(float)型ポインタ. 配列のようにアクセス可能.
        /// </summary>
#else
        /// <summary>
        /// Data pointer(float*) which can be accessed without unsafe code.
        /// </summary>
#endif
        public PointerAccessor.Float1 DataArrayFloat
        {
            get
            {
                if (dataArrayFloat == null)
                {
                    unsafe
                    {
                        dataArrayFloat = new PointerAccessor.Float1(data.data_fl);
                    }
                }
                return dataArrayFloat;
            }
        }
#if LANG_JP
                /// <summary>
                /// 行列データへのDouble型ポインタ. 配列のようにアクセス可能.
        /// </summary>
#else
        /// <summary>
        /// Data pointer(double*) which can be accessed without unsafe code.
        /// </summary>
#endif
        public PointerAccessor.Double1 DataArrayDouble
        {
            get
            {
                if (dataArrayDouble == null)
                {
                    unsafe
                    {
                        dataArrayDouble = new PointerAccessor.Double1(data.data_db);
                    }
                }
                return dataArrayDouble;
            }
        }
        #endregion

#if LANG_JP
        /// <summary>
                /// 行列の列数
                /// </summary>
#else
        /// <summary>
        /// number of columns
        /// </summary>
#endif
        public int Cols
        {
            get { return data.cols; }
        }
#if LANG_JP
                /// <summary>
                /// 行列の列数
                /// </summary>
#else
        /// <summary>
        /// number of columns
        /// </summary>
#endif
        public int Height
        {
            get { return data.height; }
        }
#if LANG_JP
                /// <summary>
                /// 行列の行数
                /// </summary>
#else
        /// <summary>
        /// number of rows
        /// </summary>
#endif
        public int Rows
        {
            get { return data.rows; }
        }
#if LANG_JP
                /// <summary>
                /// 行列の行数
                /// </summary>
#else
        /// <summary>
        /// number of rows
        /// </summary>
#endif
        public int Width
        {
            get { return data.width; }
        }
#if LANG_JP
        /// <summary>
        /// 配列の次元数を取得する (2固定)
        /// </summary>
#else
        /// <summary>
        /// Number of dimensions (=2)
        /// </summary>
#endif
        public override Int32 Dims
        {
            get { return 2; }
        }

#if LANG_JP
        /// <summary>
                /// 特定の配列要素を取得・設定する (cvmGet, cvmSet相当). 
                /// </summary>
                /// <param name="row">要素インデックスの，0を基準とした第1成分．</param>
                /// <param name="col">要素インデックスの，0を基準とした第2成分．</param>
        /// <returns>指定した要素の値</returns>
#else
        /// <summary>
        /// Get/Set the particular element of single-channel floating-point matrix (cvmGet/cvmSet)
        /// </summary>
        /// <param name="row">The zero-based index of row. </param>
        /// <param name="col">The zero-based index of column. </param>
        /// <returns>the particular element's value</returns>
#endif
        new public double this[int row, int col]
        {
            get
            {
                return CvInline.cvmGet(ptr, row, col);
            }
            set
            {
                CvInline.cvmSet(ptr, row, col, value);
            }
        }
        #endregion


        #region Operators
        /// <summary>
        /// 行列の単項+演算子
        /// </summary>
        /// <param name="a">行列</param>
        /// <returns></returns>
        public static CvMat operator +(CvMat a)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            return a.Clone();
        }
        /// <summary>
        /// 行列の単項-演算子
        /// </summary>
        /// <param name="a">行列</param>
        /// <returns></returns>
        public static CvMat operator -(CvMat a)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.AddWeighted(a, -1, a, 0, 0, result);
            return result;
        }
        /// <summary>
        /// 行列の単項not演算子
        /// </summary>
        /// <param name="a">行列</param>
        /// <returns></returns>
        public static CvMat operator ~(CvMat a)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.Not(a, result);
            return result;
        }
        /// <summary>
        /// 行列と行列の加算演算子。cvAddにより加算する。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">行列</param>
        /// <returns></returns>
        public static CvMat operator +(CvMat a, CvMat b)
        {
            if (a == null)
                throw new ArgumentNullException("a");
            if (b == null)
                throw new ArgumentNullException("b");
            CvMat result = a.Clone();
            Cv.Add(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーの加算演算子。cvAddSにより加算する。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator +(CvMat a, CvScalar b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.AddS(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列と行列の減算演算子。cvSubにより減算する。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">行列</param>
        /// <returns></returns>
        public static CvMat operator -(CvMat a, CvMat b)
        {
            if (a == null)
                throw new ArgumentNullException("a");
            if (b == null)
                throw new ArgumentNullException("b");
            CvMat result = a.Clone();
            Cv.Sub(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーの減算演算子。cvSubSにより加算する。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator -(CvMat a, CvScalar b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.SubS(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列と行列の乗算演算子。cvMatMulにより乗算する。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">行列</param>
        /// <returns></returns>
        public static CvMat operator *(CvMat a, CvMat b)
        {
            if (a == null)
                throw new ArgumentNullException("a");
            if (b == null)
                throw new ArgumentNullException("b");
            CvMat result = a.Clone();
            Cv.MatMul(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーの乗算演算子。aの要素ごとにbをかけた結果をcvAddWeightedにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator *(CvMat a, Double b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.AddWeighted(a, b, a, 0, 0, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーの除算演算子。aの要素ごとにbで割った結果をcvAddWeightedにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator /(CvMat a, double b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            if (b == 0)
            {
                throw new DivideByZeroException();
            }
            CvMat result = a.Clone();
            Cv.AddWeighted(a, 1.0 / b, a, 0, 0, result);
            return result;
        }
        /// <summary>
        /// 行列と行列のand演算子。cvAndにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">行列</param>
        /// <returns></returns>
        public static CvMat operator &(CvMat a, CvMat b)
        {
            if (a == null)
                throw new ArgumentNullException("a");
            if (b == null)
                throw new ArgumentNullException("b");
            CvMat result = a.Clone();
            Cv.And(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーのand演算子。cvAndSにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator &(CvMat a, CvScalar b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.AndS(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列と行列のor演算子。cvOrにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">行列</param>
        /// <returns></returns>
        public static CvMat operator |(CvMat a, CvMat b)
        {
            if (a == null)
                throw new ArgumentNullException("a");
            if (b == null)
                throw new ArgumentNullException("b");
            CvMat result = a.Clone();
            Cv.Or(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーのor演算子。cvOrSにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator |(CvMat a, CvScalar b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.OrS(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列と行列のxor演算子。cvXorにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">行列</param>
        /// <returns></returns>
        public static CvMat operator ^(CvMat a, CvMat b)
        {
            if (a == null)
                throw new ArgumentNullException("a");
            if (b == null)
                throw new ArgumentNullException("b");
            CvMat result = a.Clone();
            Cv.Xor(a, b, result);
            return result;
        }
        /// <summary>
        /// 行列とスカラーのxor演算子。cvXorSにより求める。
        /// </summary>
        /// <param name="a">行列</param>
        /// <param name="b">スカラー</param>
        /// <returns></returns>
        public static CvMat operator ^(CvMat a, CvScalar b)
        {
            if (a == null)
            {
                throw new ArgumentNullException("a");
            }
            CvMat result = a.Clone();
            Cv.XorS(a, b, result);
            return result;
        }
        #endregion


        #region Methods
        #region Clone
#if LANG_JP
        /// <summary>
        /// 行列のコピーを作成する (cvCloneMat)
        /// </summary>
        /// <returns>コピーされた行列</returns>
#else
        /// <summary>
        /// Creates matrix copy (cvCloneMat)
        /// </summary>
        /// <returns>a copy of input array</returns>
#endif
        public CvMat Clone()
        {
            return Cv.CloneMat(this);
        }
        object ICloneable.Clone()
        {
            return Clone();
        }
        #endregion
        #endregion


        /// <summary>
        /// 文字列形式を返す. 1チャンネルの場合のみに対応している.
        /// </summary>
        /// <returns>文字列形式</returns>
        public override string ToString()
        {
            if (ElemChannels == 1)
            {
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("CvMat(Rows={0}, Cols={1})\n", Rows, Cols);
                for (int i = 0; i < Rows; i++)
                {
                    for (int j = 0; j < Cols; j++)
                    {
                        sb.Append(Cv.mGet(this, i, j));
                        sb.Append("\t");
                    }
                    sb.AppendLine();
                }
                return sb.ToString();
            }
            return base.ToString();
        }

    }
}