root/lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/CvArr/CvSeq.cs @ 32273

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace KwsmLab.OpenCvSharp
{
    /// <summary>
    /// 拡張可能な要素のシーケンス
    /// </summary>
    public class CvSeq : CvArr, ICloneable
    {
        /// <summary>
        /// C++/CLI access to object's pointer
        /// </summary>
        protected Extern.WCvSeq _data;
        /// <summary>
        /// Data pointer
        /// </summary>
        protected IntPtr _ptr;


        #region Init and Disposal
        /// <summary>
            /// cvCreateSeqによる初期化. header_size=sizeof(CvSeq)
            /// </summary>
            /// <param name="seq_flags">生成されたシーケンスのフラグ．生成されたシーケンスが，特定のシーケンスタイプを引数にとるような関数に一切渡されない場合は，この値に0を指定してもかまわない．</param>
        /// <param name="elem_size">要素のバイトサイズ</param>
        /// <param name="storage">シーケンスが保存される場所</param>
            /// <returns></returns>
            public CvSeq( SeqType seq_flags, int elem_size, CvMemStorage storage ) 
            : this(seq_flags, SizeOf, elem_size, storage)
            {
            }
        /// <summary>
        /// cvCreateSeqによる初期化.
        /// この関数は，シーケンスヘッダをストレージ内の連続した一つのブロックとして領域確保し，
        /// 引数として渡された値を構造体のフィールド flags，elem_size， header_size，storageに引数で渡した値をセットする．
        /// そして，delta_elems にデフォルト値（関数 cvSetSeqBlockSize で再設定できる）をセットし，
        /// その他のヘッダフィールド（先頭から sizeof(CvSeq) バイト以降のスペースも含む）をクリアする．
        /// </summary>
        /// <param name="seq_flags">生成されたシーケンスのフラグ．生成されたシーケンスが，特定のシーケンスタイプを引数にとるような関数に一切渡されない場合は，この値に0を指定してもかまわない．</param>
        /// <param name="header_size">シーケンスのヘッダサイズ．sizeof(CvSeq)以上でなければならない． また，特別なタイプかその拡張が指示されている場合，そのタイプは基本タイプのヘッダと合致していなければならない．</param>
        /// <param name="elem_size">要素のバイトサイズ</param>
        /// <param name="storage">シーケンスが保存される場所</param>
        /// <returns></returns>
        public CvSeq(SeqType seq_flags, int header_size, int elem_size, CvMemStorage storage)
        {
            if (storage == null)
            {
                throw new ArgumentNullException();
            }
            this._ptr = CvDll.cvCreateSeq(seq_flags, header_size, elem_size, storage.CvPtr);
            if (this._ptr == IntPtr.Zero)
            {
                throw new Exception("CvSeqのインスタンスの生成に失敗しました.");
            }
            this._data = new Extern.WCvSeq(this._ptr);
        }
        /// <summary>
        /// ポインタから初期化
        /// </summary>
        /// <param name="ptr"></param>
        public CvSeq(IntPtr ptr)
        {
            this._ptr = ptr;
            this._data = new Extern.WCvSeq(ptr);
        }
        /// <summary>
        /// リソースの解放
        /// </summary>
        public override void Dispose()
        {
            // CvSeqは解放しない
            base.Dispose();
        }
        #endregion


        #region プロパティ
        /// <summary>
        /// sizeof(CvSeq) を取得する
        /// </summary>
        public const Int32 SizeOf = Extern.WCvSeq.SizeOf; 
        /// <summary>
        /// データポインタ(CvSeq*)を取得する
        /// </summary>
        public override IntPtr CvPtr
        {
            get { return _ptr; }
        }

        /// <summary>
                /// 様々なフラグ
                /// </summary>
                public int Flags{
                        get { return _data.flags; }
                }
                /// <summary>
                /// シーケンスのヘッダサイズ
                /// </summary>
                public int HeaderSize{
                        get { return _data.header_size; }
                }
                /// <summary>
                /// 一つ前のシーケンスへのポインタ
                /// </summary>
                public CvSeq HPrev{
                        get { 
                IntPtr ptr = _data.h_prev;
                                if(ptr != IntPtr.Zero){
                                        return new CvSeq(ptr);
                                }else{
                                        return null;
                                }
                        }
                }
                /// <summary>
                /// 一つ後のシーケンスへのポインタ
                /// </summary>
                public CvSeq HNext{
                        get { 
                IntPtr ptr = _data.h_next;
                                if(ptr != IntPtr.Zero){
                                        return new CvSeq(ptr);
                                }else{
                                        return null;
                                }
                        }
                }
                /// <summary>
                /// 一つ前のシーケンスへのポインタ（セカンダリ，構造によって意味が異なる）
                /// </summary>
                public CvSeq VPrev{
                        get { 
                            IntPtr ptr = _data.v_prev;
                                if(ptr != IntPtr.Zero){
                                        return new CvSeq(ptr);
                                }else{
                                        return null;
                                }
                        }
                }
                /// <summary>
                /// 一つ後のシーケンスへのポインタ（セカンダリ，構造によって意味が異なる）
                /// </summary>
                public CvSeq VNext{
                        get { 
                IntPtr ptr = _data.v_next;
                                if(ptr != IntPtr.Zero){
                                        return new CvSeq(ptr);
                                }else{
                                        return null;
                                }
                        }
                }
                /// <summary>
                /// 要素の総数
                /// </summary>
                public int Total{
                        get { return _data.total; }
                }
                /// <summary>
                /// シーケンス要素のサイズ（バイト単位）
                /// </summary>
                public int ElemSize{
                        get { return _data.elem_size; }
                }
                /// <summary>
                /// 最新のブロックの最大値
                /// </summary>
                public IntPtr BlockMax{
                        get { return _data.block_max; }
                }
                /// <summary>
                /// 現在の書き込みポインタ
                /// </summary>
                public IntPtr Ptr{
                        get { return _data.ptr; }
                }
                /// <summary>
                /// シーケンスを拡張させる際に，領域確保する要素数（シーケンスの粒度）
                /// </summary>
                public int DeltaElems{
                        get { return _data.delta_elems; }
                }
                /// <summary>
                /// seqが保存される領域
                /// </summary>
                public CvMemStorage Storage{
                        get { 
                IntPtr ptr = _data.storage;
                                if(ptr != IntPtr.Zero){
                                        return new CvMemStorage(ptr, false);
                                }else{
                                        return null;
                                }
                        }
                }
                /// <summary>
                /// 空きブロックリスト
                /// </summary>
                public CvSeqBlock FreeBlocks{
                        get { 
                IntPtr ptr = _data.free_blocks;
                                if(ptr != IntPtr.Zero){
                                        return new CvSeqBlock(ptr);
                                }else{
                                        return null;
                                }
                        }
                }
                /// <summary>
                /// 先頭シーケンスブロックへのポインタ
                /// </summary>
                public CvSeqBlock First{
                        get { 
                    IntPtr ptr = _data.first;
                                if(ptr != IntPtr.Zero){
                                        return new CvSeqBlock(ptr);
                                }else{
                                        return null;
                                }       
                        }
                }

        #endregion


        #region OpenCV メソッド
        #region Clear
            /// <summary>
            /// 与えられたインデックスをもつ要素を削除する (cvClearSeq相当)
            /// </summary>
        public virtual void Clear()
        {
            Cv.ClearSeq(this);
        }
            #endregion 
        #region Clone
        /// <summary>
        /// ヘッダ，ROI，データを含む画像の完全なコピーを作成する(cvCloneSeq相当)
        /// </summary>
        /// <returns>この画像の完全なコピー</returns>
        public virtual CvSeq Clone()
        {
            return Cv.CloneSeq(this);
        }
        /// <summary>
        /// 入力行列のコピーを作成し返す
        /// </summary>
        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ（もしデータがあれば）を保存する出力ストレージ． nullの場合，入力シーケンスに含まれるストレージを使用する．</param>
        /// <returns>コピーされたCvSeq</returns>
        public virtual CvSeq Clone(CvMemStorage storage)
        {
            return Cv.CloneSeq(this, storage);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        object ICloneable.Clone()
        {
            return Clone();
        }
        #endregion
        #region GetElem
        /// <summary>
        /// 与えられたインデックスを持つ要素をシーケンスの中から求め，その要素を返す．
        /// </summary>
        /// <param name="index">要素のインデックス. 負のインデックスの指定も可能で, 例えば，-1はシーケンスの最後の要素，-2は最後の一つ前を指す.</param>
        /// <returns>与えられたインデックスを持つ要素．要素が見つからない場合はnull．</returns>
        public virtual T? GetElem<T>(int index) where T : struct
        {
            return Cv.GetSeqElem<T>(this, index);
        }
        #endregion
        #region Insert
            /// <summary>
            /// シーケンス内の要素を指定した挿入位置から近い側のシーケンスの端にシフトし，element の内容をその位置にコピーする (cvSeqInsert相当)．
            /// 挿入された要素への参照を返す．
            /// </summary>
            /// <param name="before_index">要素が挿入されるインデックス（このインデックスの前に挿入される）</param>
            /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param>
            /// <returns>追加された要素</returns>
        public virtual T Insert<T>(int before_index, T element) where T : struct
            {
                    return Cv.SeqInsert<T>(this, before_index, element);
            }
            #endregion 
        #region Remove
            /// <summary>
            /// 与えられたインデックスをもつ要素を削除する (cvSeqRemove相当)
            /// </summary>
            /// <param name="index">削除される要素のインデックス</param>
            public virtual void Remove( int index )
            {
                    Cv.SeqRemove(this, index);
            }
            #endregion 
        #region Pop
        /// <summary>
        /// シーケンスの末尾から一つの要素を削除する．
        /// シーケンスが既に空の場合は，エラーを返す．この関数の計算量は O(1) である．
        /// </summary>
        public virtual T Pop<T>() where T : struct
        {
            T result;
            Cv.SeqPop<T>(this, out result);
            return result;
        }
        #endregion
        #region PopFront
        /// <summary>
        /// シーケンスの先頭から一つの要素を削除する (cvSeqPopFront相当)．
        /// シーケンスが既に空の場合は，エラーを返す．この関数の計算量は O(1) である．
        /// </summary>
        /// <returns>削除された要素</returns>
        public virtual T PopFront<T>() where T : struct
        {
            T result;
            Cv.SeqPopFront<T>(this, out result);
            return result;
        }
        #endregion 
        #region Push
        /// <summary>
        /// シーケンスの末尾に要素一つ分の領域を確保する．
        /// </summary>
        /// <returns>追加された要素へのポインタ</returns>
        public virtual IntPtr Push()
        {
            return Cv.SeqPush(this);
        }
        /// <summary>
        /// シーケンスの末尾に要素を追加し，割り付けられた要素を返す．
        /// 入力の element が null の場合，この関数は単に要素一つ分の領域を確保する．
        /// </summary>
        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param>
        /// <returns>追加された要素へのポインタ</returns>
        public virtual T Push<T>(T element) where T : struct
        {
            return Cv.SeqPush<T>(this, element);
        }
        #endregion
        #region PushFront
            /// <summary>
            /// シーケンスの先頭に要素を追加し，割り付けられた要素を返す (cvSeqPushFront相当)．
            /// </summary>
            /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param>
            /// <returns>追加された要素</returns>
        public virtual T PushFront<T>(T element) where T : struct
            {
                    return Cv.SeqPushFront<T>(this, element);
            }
            #endregion 
            #region Search
            /// <summary>
            /// シーケンスの中から要素を検索する (cvSeqSearch相当)．
            /// シーケンスがソートされていれば，O(log(N))の二分探索法が用いられる．その他の場合は，単純な線形探索が用いられる．
            /// 要素が見つからない場合，この関数はnullを返し，インデックスにはシーケンスの要素数をセットする．
            /// 線形探索を用いて要素を見つけた場合，インデックスにはseq(i)>elemである最小のインデックスiがセットされる． 
            /// </summary>
            /// <param name="elem">検索する要素</param>
            /// <param name="func">要素の関係に応じて，負・0・正の値を返す比較関数</param>
            /// <param name="is_sorted">シーケンスがソート済みか否かを示すフラグ</param>
            /// <param name="elem_idx">出力パラメータ．見つかった要素のインデックス．</param>
            public virtual IntPtr Search( IntPtr elem, CvCmpFunc func, bool is_sorted, out int elem_idx ) 
            {
            return Cv.SeqSearch(this, elem, func, is_sorted, out elem_idx);
            }
            #endregion
            #region SetBlockSize
            /// <summary>
            /// メモリ確保サイズを指定する (cvcvSetSeqBlockSize相当)．
            /// シーケンスバッファ上の空き領域を使い果たした場合，関数は delta_elems シーケンス要素分の領域確保を行う．
            /// 確保したブロックが前のブロックの直後になる場合，二つのブロックは接続されるが，それ以外では，新しいシーケンスブロックが生成される．
            /// そのため，このパラメータを大きくすることによってシーケンスブロックの断片化は押さえられるものの，ストレージ中の多くのスペースが浪費されることになる．
            /// シーケンス生成時に，パラメータ delta_elems にはデフォルト値≈1K がセットされる．シーケンス生成後，この関数をいつでも呼ぶことができ，
            /// 以降の領域確保の際にその値が使われる．この関数によって，渡されたパラメータ値をメモリストレージの制限に合わせるために変更することができる． 
            /// </summary>
            /// <param name="delta_elems">シーケンス要素のブロックサイズ</param>
            public virtual void SetBlockSize( int delta_elems )
            {
                    Cv.SetSeqBlockSize(this, delta_elems);
            }
            #endregion 
        #region Slice
        /// <summary>
        /// シーケンススライスのための別のヘッダを作成する
        /// </summary>
        /// <param name="slice">抽出するシーケンスの一部分</param>
        /// <returns></returns>
        public virtual CvSeq Slice(CvSlice slice)
        {
            return Cv.SeqSlice(this, slice);
        }
        /// <summary>
        /// シーケンススライスのための別のヘッダを作成する
        /// </summary>
        /// <param name="slice">抽出するシーケンスの一部分</param>
        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ（もしデータがあれば）を保存する出力ストレージ． nullの場合，この関数は入力シーケンスに含まれるストレージを使用する</param>
        /// <returns></returns>
        public virtual CvSeq Slice(CvSlice slice, CvMemStorage storage)
        {
            return Cv.SeqSlice(this, slice, storage);
        }
        /// <summary>
        /// シーケンススライスのための別のヘッダを作成する
        /// </summary>
        /// <param name="slice">抽出するシーケンスの一部分</param>
        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ（もしデータがあれば）を保存する出力ストレージ． nullの場合，この関数は入力シーケンスに含まれるストレージを使用する</param>
        /// <param name="copy_data">抽出されたスライスの要素をコピーするかしないかを示すフラグ</param>
        /// <returns></returns>
        public virtual CvSeq Slice(CvSlice slice, CvMemStorage storage, bool copy_data)
        {
            return Cv.SeqSlice(this, slice, storage, copy_data);
        }
        #endregion
            #region Sort
            /// <summary>
            /// シーケンスの要素を，指定した比較関数を用いてソートする (cvSeqSort相当)
            /// </summary>
            /// <param name="func">要素の関係に応じて，負・0・正の値を返す比較関数</param>
            public virtual void Sort( CvCmpFunc func )
            {
                    Cv.SeqSort(this, func);
            }
            #endregion
        #region StartRead
            /// <summary>
            /// リーダの状態を初期化する．
            /// この後，先頭から末尾までの全シーケンス要素は，続いて呼ばれるマクロCV_READ_SEQ_ELEM( read_elem, reader )（順方向読み出しの場合）
            /// あるいは，マクロ CV_REV_READ_SEQ_ELEM( read_elem, reader )（逆方向読み出しの場合）を用いて，読み出しが可能になる．
            /// </summary>
            /// <param name="reader">リーダ（reader）の状態．この関数で初期化される．</param>
        public virtual void StartRead(CvSeqReader reader) 
            {
                    Cv.StartReadSeq(this, reader);
            }
            /// <summary>
            /// リーダの状態を初期化する．
            /// この後，先頭から末尾までの全シーケンス要素は，続いて呼ばれるマクロCV_READ_SEQ_ELEM( read_elem, reader )（順方向読み出しの場合）
            /// あるいは，マクロ CV_REV_READ_SEQ_ELEM( read_elem, reader )（逆方向読み出しの場合）を用いて，読み出しが可能になる．
            /// </summary>
            /// <param name="reader">リーダ（reader）の状態．この関数で初期化される．</param>
            /// <param name="reverse">シーケンス走査方向の指定．reverse が false の場合，リーダは先頭のシーケンス要素に位置する．それ以外は最後の要素に位置する．</param>
        public virtual void StartRead(CvSeqReader reader, bool reverse)
            {
                    Cv.StartReadSeq(this, reader, reverse);
            }
            #endregion
        #region ToArray
        /// <summary>
        /// シーケンスをメモリ内の連続した一つのブロックにコピーする
        /// </summary>
        /// <returns>出力される配列</returns>
        public T[] ToArray<T>() where T : struct
        {
            T[] elements;
            return Cv.CvtSeqToArray<T>(this, out elements);
        }
        /// <summary>
        /// シーケンスをメモリ内の連続した一つのブロックにコピーする
        /// </summary>
        /// <param name="slice">配列へコピーするシーケンス内の部分</param>
        /// <returns>出力される配列. outされる引数 element と同じ値.</returns>
        public T[] ToArray<T>(CvSlice slice) where T : struct
        {
            T[] elements;
            return Cv.CvtSeqToArray<T>(this, out elements, slice);
        }
        #endregion
        #endregion

    }
}