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

Revision 32940, 35.8 kB (checked in by schima, 5 years ago)

CvTreeNode?.Initialize

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.Linq;
9using System.Runtime.InteropServices;
10using System.Text;
11
12namespace KwsmLab.OpenCvSharp
13{
14#if LANG_JP
15    /// <summary>
16    /// 拡張可能な要素のシーケンス
17    /// </summary>
18#else
19    /// <summary>
20    /// Growable sequence of elements
21    /// </summary>
22#endif
23    public class CvSeq : CvTreeNode<CvSeq>, ICloneable
24    {
25        /// <summary>
26        /// C++/CLI access to object's pointer
27        /// </summary>
28        new protected Extern.WCvSeq _data;
29
30
31        #region Init and Disposal
32#if LANG_JP
33        /// <summary>
34        /// 既定の初期化
35        /// </summary>
36#else
37        /// <summary>
38        /// Default constructor
39        /// </summary>
40#endif
41        protected CvSeq()
42            : base()
43        {
44            this._ptr = IntPtr.Zero;
45            this._data = null;
46        }
47#if LANG_JP
48        /// <summary>
49        /// シーケンスを生成する. header_size=sizeof(CvSeq)
50        /// </summary>
51        /// <param name="seq_flags">生成されたシーケンスのフラグ.生成されたシーケンスが,特定のシーケンスタイプを引数にとるような関数に一切渡されない場合は,この値に0を指定してもかまわない.そうでない場合は,定義済みのシーケンスタイプのリストから適切なタイプが選択されなければならない.</param>
52        /// <param name="elem_size">シーケンスの要素サイズ(バイト単位).サイズはシーケンスタイプと合致しなければならない.例えば,点群のシーケンスを作成する場合,要素タイプにCV_SEQ_ELTYPE_POINTを指定し,パラメータ elem_size は sizeof(CvPoint) と等しくなければならない.</param>
53        /// <param name="storage">シーケンスが保存される場所</param>
54        /// <returns></returns>
55#else
56        /// <summary>
57        /// Creates sequence. header_size=sizeof(CvSeq)
58        /// </summary>
59        /// <param name="seq_flags">Flags of the created sequence. If the sequence is not passed to any function working with a specific type of sequences, the sequence value may be set to 0, otherwise the appropriate type must be selected from the list of predefined sequence types. </param>
60        /// <param name="elem_size">Size of the sequence elements in bytes. The size must be consistent with the sequence type. For example, for a sequence of points to be created, the element type CV_SEQ_ELTYPE_POINT should be specified and the parameter elem_size must be equal to sizeof(CvPoint). </param>
61        /// <param name="storage">Sequence location. </param>
62        /// <returns></returns>
63#endif
64        public CvSeq(SeqType seq_flags, int elem_size, CvMemStorage storage)
65            : this(seq_flags, SizeOf, elem_size, storage)
66        {
67        }
68#if LANG_JP
69        /// <summary>
70        /// シーケンスを生成する
71        /// </summary>
72        /// <param name="seq_flags">生成されたシーケンスのフラグ.生成されたシーケンスが,特定のシーケンスタイプを引数にとるような関数に一切渡されない場合は,この値に0を指定してもかまわない.そうでない場合は,定義済みのシーケンスタイプのリストから適切なタイプが選択されなければならない.</param>
73        /// <param name="header_size">シーケンスのヘッダサイズ.sizeof(CvSeq)以上でなければならない. また,特別なタイプかその拡張が指示されている場合,そのタイプは基本タイプのヘッダと合致していなければならない.</param>
74        /// <param name="elem_size">シーケンスの要素サイズ(バイト単位).サイズはシーケンスタイプと合致しなければならない.例えば,点群のシーケンスを作成する場合,要素タイプにCV_SEQ_ELTYPE_POINTを指定し,パラメータ elem_size は sizeof(CvPoint) と等しくなければならない.</param>
75        /// <param name="storage">シーケンスが保存される場所</param>
76#else
77        /// <summary>
78        /// Creates sequence
79        /// </summary>
80        /// <param name="seq_flags">Flags of the created sequence. If the sequence is not passed to any function working with a specific type of sequences, the sequence value may be set to 0, otherwise the appropriate type must be selected from the list of predefined sequence types. </param>
81        /// <param name="header_size">Size of the sequence header; must be greater or equal to sizeof(CvSeq). If a specific type or its extension is indicated, this type must fit the base type header. </param>
82        /// <param name="elem_size">Size of the sequence elements in bytes. The size must be consistent with the sequence type. For example, for a sequence of points to be created, the element type CV_SEQ_ELTYPE_POINT should be specified and the parameter elem_size must be equal to sizeof(CvPoint). </param>
83        /// <param name="storage">Sequence location. </param>
84#endif
85        public CvSeq(SeqType seq_flags, int header_size, int elem_size, CvMemStorage storage)
86        {
87            if (storage == null)
88            {
89                throw new ArgumentNullException();
90            }
91            IntPtr ptr = CvDll.cvCreateSeq(seq_flags, header_size, elem_size, storage.CvPtr);
92            Initialize(ptr);
93        }
94
95#if LANG_JP
96        /// <summary>
97        /// ポインタから初期化
98        /// </summary>
99        /// <param name="ptr">struct CvSeq*</param>
100#else
101        /// <summary>
102        /// Initializes from native pointer
103        /// </summary>
104        /// <param name="ptr">struct CvSeq*</param>
105#endif
106        public CvSeq(IntPtr ptr)
107        {
108            Initialize(ptr);
109        }
110#if LANG_JP
111        /// <summary>
112        /// ポインタから初期化
113        /// </summary>
114        /// <param name="ptr">struct CvSeq*</param>
115#else
116        /// <summary>
117        /// Initializes from native pointer
118        /// </summary>
119        /// <param name="ptr">struct CvSeq*</param>
120#endif
121        protected override void Initialize(IntPtr ptr)
122        {
123            base.Initialize(ptr);
124            this._ptr = ptr;
125            this._data = new Extern.WCvSeq(ptr);
126        }
127
128
129#if LANG_JP
130        /// <summary>
131        /// リソースの解放
132        /// </summary>
133#else
134        /// <summary>
135        /// Releases CvSeq
136        /// </summary>
137#endif
138        public override void Dispose()
139        {
140            // CvSeqは解放しない
141            base.Dispose();
142        }
143        #endregion
144
145
146        #region Properties
147        /// <summary>
148        /// sizeof(CvSeq)
149        /// </summary>
150        new public const int SizeOf = Extern.WCvSeq.SizeOf;
151
152
153#if LANG_JP
154                /// <summary>
155                /// 一つ前のシーケンスへのポインタ
156                /// </summary>
157#else
158        /// <summary>
159        /// previous sequence
160        /// </summary>
161#endif
162        public override CvSeq HPrev
163        {
164            get
165            {
166                IntPtr ptr = _data.h_prev;
167                if (ptr != IntPtr.Zero)
168                {
169                    return new CvSeq(ptr);
170                }
171                else
172                {
173                    return null;
174                }
175            }
176        }
177#if LANG_JP
178                /// <summary>
179                /// 一つ後のシーケンスへのポインタ
180                /// </summary>
181#else
182        /// <summary>
183        /// next sequence
184        /// </summary>
185#endif
186        public override CvSeq HNext
187        {
188            get
189            {
190                IntPtr ptr = _data.h_next;
191                if (ptr != IntPtr.Zero)
192                {
193                    return new CvSeq(ptr);
194                }
195                else
196                {
197                    return null;
198                }
199            }
200        }
201#if LANG_JP
202                /// <summary>
203                /// 一つ前のシーケンスへのポインタ(セカンダリ,構造によって意味が異なる)
204                /// </summary>
205#else
206        /// <summary>
207        /// 2nd previous sequence
208        /// </summary>
209#endif
210        public override CvSeq VPrev
211        {
212            get
213            {
214                IntPtr ptr = _data.v_prev;
215                if (ptr != IntPtr.Zero)
216                {
217                    return new CvSeq(ptr);
218                }
219                else
220                {
221                    return null;
222                }
223            }
224        }
225#if LANG_JP
226                /// <summary>
227                /// 一つ後のシーケンスへのポインタ(セカンダリ,構造によって意味が異なる)
228                /// </summary>
229#else
230        /// <summary>
231        /// 2nd next sequence
232        /// </summary>
233#endif
234        public override CvSeq VNext
235        {
236            get
237            {
238                IntPtr ptr = _data.v_next;
239                if (ptr != IntPtr.Zero)
240                {
241                    return new CvSeq(ptr);
242                }
243                else
244                {
245                    return null;
246                }
247            }
248        }
249#if LANG_JP
250                /// <summary>
251                /// 要素の総数
252                /// </summary>
253#else
254        /// <summary>
255        /// total number of elements
256        /// </summary>
257#endif
258        public int Total
259        {
260            get { return _data.total; }
261        }
262#if LANG_JP
263                /// <summary>
264                /// シーケンス要素のサイズ(バイト単位)
265                /// </summary>
266#else
267        /// <summary>
268        /// size of sequence element in bytes
269        /// </summary>
270#endif
271        public int ElemSize
272        {
273            get { return _data.elem_size; }
274        }
275#if LANG_JP
276                /// <summary>
277                /// 最新のブロックの最大値
278                /// </summary>
279#else
280        /// <summary>
281        /// maximal bound of the last block
282        /// </summary>
283#endif
284        public IntPtr BlockMax
285        {
286            get { return _data.block_max; }
287        }
288#if LANG_JP
289                /// <summary>
290                /// 現在の書き込みポインタ
291                /// </summary>
292#else
293        /// <summary>
294        /// current write pointer
295        /// </summary>
296#endif
297        public IntPtr Ptr
298        {
299            get { return _data.ptr; }
300        }
301#if LANG_JP
302                /// <summary>
303                /// シーケンスを拡張させる際に,領域確保する要素数(シーケンスの粒度)
304                /// </summary>
305#else
306        /// <summary>
307        /// how many elements allocated when the sequence grows (sequence granularity)
308        /// </summary>
309#endif
310        public int DeltaElems
311        {
312            get { return _data.delta_elems; }
313        }
314#if LANG_JP
315                /// <summary>
316                /// seqが保存される領域
317                /// </summary>
318#else
319        /// <summary>
320        /// where the seq is stored
321        /// </summary>
322#endif
323        public CvMemStorage Storage
324        {
325            get
326            {
327                IntPtr ptr = _data.storage;
328                if (ptr != IntPtr.Zero)
329                {
330                    return new CvMemStorage(ptr, false);
331                }
332                else
333                {
334                    return null;
335                }
336            }
337        }
338#if LANG_JP
339                /// <summary>
340                /// 空きブロックリスト
341                /// </summary>
342#else
343        /// <summary>
344        /// free blocks list
345        /// </summary>
346#endif
347        public CvSeqBlock FreeBlocks
348        {
349            get
350            {
351                IntPtr ptr = _data.free_blocks;
352                if (ptr != IntPtr.Zero)
353                {
354                    return new CvSeqBlock(ptr);
355                }
356                else
357                {
358                    return null;
359                }
360            }
361        }
362#if LANG_JP
363                /// <summary>
364                /// 先頭シーケンスブロックへのポインタ
365                /// </summary>
366#else
367        /// <summary>
368        /// pointer to the first sequence block
369        /// </summary>
370#endif
371        public CvSeqBlock First
372        {
373            get
374            {
375                IntPtr ptr = _data.first;
376                if (ptr != IntPtr.Zero)
377                {
378                    return new CvSeqBlock(ptr);
379                }
380                else
381                {
382                    return null;
383                }
384            }
385        }
386        #endregion
387
388
389        #region Methods
390        #region Clone
391#if LANG_JP
392        /// <summary>
393        /// 入力行列のコピーを作成し返す (cvCloneSeq).
394        /// </summary>
395        /// <returns>コピーされたCvSeq</returns>
396#else
397        /// <summary>
398        /// Creates a copy of sequence (cvCloneSeq).
399        /// </summary>
400        /// <returns></returns>
401#endif
402        public virtual CvSeq Clone()
403        {
404            return Cv.CloneSeq(this);
405        }
406#if LANG_JP
407        /// <summary>
408        /// 入力行列のコピーを作成し返す (cvCloneSeq).
409        /// </summary>
410        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ(もしデータがあれば)を保存する出力ストレージ. nullの場合,入力シーケンスに含まれるストレージを使用する.</param>
411        /// <returns>コピーされたCvSeq</returns>
412#else
413        /// <summary>
414        /// Creates a copy of sequence (cvCloneSeq).
415        /// </summary>
416        /// <param name="storage">The destination storage to keep the new sequence header and the copied data if any. If it is null, the function uses the storage containing the input sequence. </param>
417        /// <returns></returns>
418#endif
419        public virtual CvSeq Clone(CvMemStorage storage)
420        {
421            return Cv.CloneSeq(this, storage);
422        }
423        /// <summary>
424        /// ICloneable.Clone
425        /// </summary>
426        /// <returns></returns>
427        object ICloneable.Clone()
428        {
429            return Clone();
430        }
431        #endregion
432        #region ElemIdx
433#if LANG_JP
434        /// <summary>
435        /// 指定されたシーケンスの要素のインデックスを返す (cvSeqElemIdx).
436        /// </summary>
437        /// <typeparam name="T">要素の型</typeparam>
438        /// <param name="element">シーケンス要素</param>
439        /// <returns>指定されたシーケンス要素のインデックス</returns>
440#else
441        /// <summary>
442        /// Returns index of concrete sequence element (cvSeqElemIdx).
443        /// </summary>
444        /// <typeparam name="T">Element type</typeparam>
445        /// <param name="element">the element within the sequence. </param>
446        /// <returns>the index of a sequence element or a negative number if the element is not found.</returns>
447#endif
448        public int ElemIdx<T>(T element) where T : struct
449        {
450            return Cv.SeqElemIdx<T>(this, element);
451        }
452#if LANG_JP
453        /// <summary>
454        /// 指定されたシーケンスの要素のインデックスを返す (cvSeqElemIdx).
455        /// </summary>
456        /// <typeparam name="T">要素の型</typeparam>
457        /// <param name="element">シーケンス要素</param>
458        /// <param name="block">要素を含むシーケンスブロックのアドレスがこの場所に保存される.</param>
459        /// <returns>指定されたシーケンス要素のインデックス</returns>
460#else
461        /// <summary>
462        /// Returns index of concrete sequence element (cvSeqElemIdx).
463        /// </summary>
464        /// <typeparam name="T">Element type</typeparam>
465        /// <param name="element">the element within the sequence. </param>
466        /// <param name="block">the address of the sequence block that contains the element is stored in this location. </param>
467        /// <returns>the index of a sequence element or a negative number if the element is not found.</returns>
468#endif
469        public int ElemIdx<T>(T element, out CvSeqBlock block) where T : struct
470        {
471            return Cv.SeqElemIdx<T>(this, element, out block);
472        }
473        #endregion
474        #region Insert
475#if LANG_JP
476        /// <summary>
477        /// シーケンスの中に要素を挿入する (cvSeqInsert).
478        /// </summary>
479        /// <typeparam name="T">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam>
480        /// <param name="before_index">要素が挿入されるインデックス(このインデックスの前に挿入される)</param>
481        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param>
482        /// <returns>追加された要素</returns>
483#else
484        /// <summary>
485        /// Inserts element in sequence middle (cvSeqInsert).
486        /// </summary>
487        /// <typeparam name="T">Element type</typeparam>
488        /// <param name="before_index">Index before which the element is inserted. Inserting before 0 (the minimal allowed value of the parameter) is equal to cvSeqPushFront and inserting before seq->total (the maximal allowed value of the parameter) is equal to cvSeqPush. </param>
489        /// <param name="element">Inserted element. </param>
490        /// <returns>Inserted element. </returns>
491#endif
492        public virtual T Insert<T>(int before_index, T element) where T : struct
493        {
494            return Cv.SeqInsert<T>(this, before_index, element);
495        }
496        #endregion
497        #region InsertSlice
498#if LANG_JP
499        /// <summary>
500        /// シーケンス内に配列を挿入する (cvSeqInsertSlice).
501        /// </summary>
502        /// <param name="before_index">配列が挿入される場所へのインデックス(インデックスの前に挿入される).</param>
503        /// <param name="from_arr">追加される要素の配列.</param>
504#else
505        /// <summary>
506        /// Inserts array in the middle of sequence (cvSeqInsertSlice).
507        /// </summary>
508        /// <param name="before_index">The part of the sequence to remove. </param>
509        /// <param name="from_arr">The array to take elements from. </param>
510#endif
511        public virtual void InsertSlice(int before_index, CvArr from_arr)
512        {
513            Cv.SeqInsertSlice(this, before_index, from_arr);
514        }
515        #endregion
516        #region Invert
517#if LANG_JP
518        /// <summary>
519        /// シーケンス要素の順序を反転させる (cvSeqInvert).
520        /// </summary>
521#else
522        /// <summary>
523        /// Reverses the order of sequence elements (cvSeqInvert).
524        /// </summary>
525#endif
526        public void Invert()
527        {
528            Cv.SeqInvert(this);
529        }
530        #endregion
531        #region Remove
532#if LANG_JP
533        /// <summary>
534        /// 与えられたインデックスをもつ要素を削除する (cvSeqRemove).
535        /// </summary>
536        /// <param name="index">削除される要素のインデックス</param>
537#else
538        /// <summary>
539        /// Removes element from sequence middle (cvSeqRemove).
540        /// </summary>
541        /// <param name="index">Index of removed element. </param>
542#endif
543        public virtual void Remove(int index)
544        {
545            Cv.SeqRemove(this, index);
546        }
547        #endregion
548        #region RemoveSlice
549#if LANG_JP
550        /// <summary>
551        /// シーケンススライスを削除する (cvSeqRemoveSlice).
552        /// </summary>
553        /// <param name="slice">削除するシーケンスの一部分. </param>
554#else
555        /// <summary>
556        /// Removes sequence slice (cvSeqRemoveSlice).
557        /// </summary>
558        /// <param name="slice">The part of the sequence to remove. </param>
559#endif
560        public void RemoveSlice(CvSlice slice)
561        {
562            Cv.SeqRemoveSlice(this, slice);
563        }
564        #endregion
565        #region Pop
566#if LANG_JP
567        /// <summary>
568        /// シーケンスの末尾から一つの要素を削除する (cvSeqPop).
569        /// </summary>
570        /// <typeparam name="T">要素の型</typeparam>
571        /// <returns>削除した要素</returns>
572#else
573        /// <summary>
574        /// Removes element from sequence end (cvSeqPop).
575        /// </summary>
576        /// <typeparam name="T">Element type</typeparam>
577        /// <returns>removed element</returns>
578#endif
579        public virtual T Pop<T>() where T : struct
580        {
581            T result;
582            Cv.SeqPop<T>(this, out result);
583            return result;
584        }
585        #endregion
586        #region PopFront
587#if LANG_JP
588        /// <summary>
589        /// シーケンスの先頭から一つの要素を削除する (cvSeqPopFront).
590        /// </summary>
591        /// <typeparam name="T">出力先オブジェクトの型</typeparam>
592        /// <returns>削除した要素をコピーする出力先</returns>
593#else
594        /// <summary>
595        /// Removes element from sequence beginning (cvSeqPopFront).
596        /// </summary>
597        /// <typeparam name="T">Element type</typeparam>
598        /// <returns>removed element</returns>
599#endif
600        public virtual T PopFront<T>() where T : struct
601        {
602            T result;
603            Cv.SeqPopFront<T>(this, out result);
604            return result;
605        }
606        #endregion
607        #region PopMulti
608#if LANG_JP
609        /// <summary>
610        /// 複数の要素をシーケンスのどちらかの端(先頭か末尾)から削除する (cvSeqPopMulti).
611        /// </summary>
612        /// <typeparam name="T">削除する要素の型</typeparam>
613        /// <param name="count">削除される要素数.</param>
614        /// <param name="in_front">変更するシーケンスの端を指定するフラグ.</param>
615#else
616        /// <summary>
617        /// Removes several elements from the either end of sequence (cvSeqPopMulti).
618        /// </summary>
619        /// <typeparam name="T">Element type</typeparam>
620        /// <param name="count">Number of elements to pop. </param>
621        /// <param name="in_front">The flags specifying the modified sequence end</param>
622#endif
623        public T[] PopMulti<T>(int count, InsertPosition in_front) where T : struct
624        {
625            T[] elements;
626            Cv.SeqPopMulti<T>(this, out elements, count, in_front);
627            return elements;
628        }
629        #endregion
630        #region Push
631#if LANG_JP
632        /// <summary>
633        /// シーケンスの末尾に要素一つ分の領域を確保する (cvSeqPush).
634        /// </summary>
635        /// <returns></returns>
636#else
637        /// <summary>
638        /// allocates a space for one more element (cvSeqPush).
639        /// </summary>
640        /// <returns>pointer to the allocated element. </returns>
641#endif
642        public virtual IntPtr Push()
643        {
644            return Cv.SeqPush(this);
645        }
646#if LANG_JP
647        /// <summary>
648        /// シーケンスの末尾に要素を追加し,割り付けられた要素を返す (cvSeqPush).
649        /// 入力の element が null の場合,この関数は単に要素一つ分の領域を確保する.
650        /// </summary>
651        /// <typeparam name="T">要素の型</typeparam>
652        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param>
653        /// <returns>追加された要素</returns>
654#else
655        /// <summary>
656        /// Adds element to sequence end (cvSeqPush).
657        /// </summary>
658        /// <typeparam name="T">Element type</typeparam>
659        /// <param name="element">Added element. </param>
660        /// <returns>pointer to the allocated element. </returns>
661#endif
662        public virtual T Push<T>(T? element) where T : struct
663        {
664            return Cv.SeqPush<T>(this, element);
665        }
666        #endregion
667        #region PushFront
668#if LANG_JP
669        /// <summary>
670        /// シーケンスの先頭に要素を追加し,割り付けられた要素へのポインタを返す (cvSeqPushFront).
671        /// 入力の element が null の場合,この関数は単に要素一つ分の領域を確保する.
672        /// </summary>
673        /// <typeparam name="T">追加する要素の型. プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam>
674        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param>
675        /// <returns>追加された要素</returns>
676#else
677        /// <summary>
678        /// Adds element to sequence beginning (cvSeqPushFront).
679        /// </summary>
680        /// <typeparam name="T">Element type</typeparam>
681        /// <param name="element">Added element. </param>
682        /// <returns>pointer to the added element</returns>
683#endif
684        public virtual T PushFront<T>(T? element) where T : struct
685        {
686            return Cv.SeqPushFront<T>(this, element);
687        }
688        #endregion
689        #region PushMulti
690#if LANG_JP
691        /// <summary>
692        /// 複数の要素をシーケンスのどちらかの端(先頭か末尾)に追加する (cvSeqPushMulti).
693        /// </summary>
694        /// <typeparam name="T">追加する要素の型</typeparam>
695        /// <param name="elements">追加される要素群.</param>
696        /// <param name="in_front">変更するシーケンスの端を指定するフラグ.</param>
697#else
698        /// <summary>
699        /// Pushes several elements to the either end of sequence (cvSeqPushMulti).
700        /// </summary>
701        /// <typeparam name="T">Element type</typeparam>
702        /// <param name="elements">Added elements. </param>
703        /// <param name="in_front">The flags specifying the modified sequence end</param>
704#endif
705        public void PushMulti<T>(T[] elements, InsertPosition in_front) where T : struct
706        {
707            Cv.SeqPushMulti<T>(this, elements, in_front);
708        }
709        #endregion
710        #region Search
711#if LANG_JP
712        /// <summary>
713        /// シーケンスの中から要素を検索する (cvSeqSearch).
714        /// </summary>
715        /// <param name="elem">検索する要素</param>
716        /// <param name="func">要素の関係に応じて,負・0・正の値を返す比較関数</param>
717        /// <param name="is_sorted">シーケンスがソート済みか否かを示すフラグ</param>
718        /// <param name="elem_idx">出力パラメータ.見つかった要素のインデックス.</param>
719#else
720        /// <summary>
721        /// Searches element in sequence (cvSeqSearch).
722        /// </summary>
723        /// <param name="elem">The element to look for </param>
724        /// <param name="func">The comparison function that returns negative, zero or positive value depending on the elements relation</param>
725        /// <param name="is_sorted">Whether the sequence is sorted or not. </param>
726        /// <param name="elem_idx">Output parameter; index of the found element. </param>
727        /// <returns></returns>
728#endif
729        public virtual IntPtr Search(IntPtr elem, CvCmpFunc func, bool is_sorted, out int elem_idx)
730        {
731            return Cv.SeqSearch(this, elem, func, is_sorted, out elem_idx);
732        }
733        #endregion
734        #region SetBlockSize
735#if LANG_JP
736        /// <summary>
737        /// シーケンスのブロックサイズを設定する
738        /// </summary>
739        /// <param name="delta_elems">シーケンス要素のブロックサイズ</param>
740#else
741        /// <summary>
742        /// Sets up sequence block size
743        /// </summary>
744        /// <param name="delta_elems">Desirable sequence block size in elements. </param>
745#endif
746        public virtual void SetBlockSize(int delta_elems)
747        {
748            Cv.SetSeqBlockSize(this, delta_elems);
749        }
750        #endregion
751        #region Slice
752#if LANG_JP
753        /// <summary>
754        /// シーケンススライスのための別のヘッダを作成する (cvSeqSlice).
755        /// </summary>
756        /// <param name="slice">抽出するシーケンスの一部分</param>
757        /// <returns></returns>
758#else
759        /// <summary>
760        /// Makes separate header for the sequence slice (cvSeqSlice).
761        /// </summary>
762        /// <param name="slice">The part of the sequence to extract. </param>
763        /// <returns></returns>
764#endif
765        public virtual CvSeq Slice(CvSlice slice)
766        {
767            return Cv.SeqSlice(this, slice);
768        }
769#if LANG_JP
770        /// <summary>
771        /// シーケンススライスのための別のヘッダを作成する (cvSeqSlice).
772        /// </summary>
773        /// <param name="slice">抽出するシーケンスの一部分</param>
774        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ(もしデータがあれば)を保存する出力ストレージ. nullの場合,この関数は入力シーケンスに含まれるストレージを使用する</param>
775        /// <returns></returns>
776#else
777        /// <summary>
778        /// Makes separate header for the sequence slice (cvSeqSlice).
779        /// </summary>
780        /// <param name="slice">The part of the sequence to extract. </param>
781        /// <param name="storage">The destination storage to keep the new sequence header and the copied data if any. If it is null, the function uses the storage containing the input sequence. </param>
782        /// <returns></returns>
783#endif
784        public virtual CvSeq Slice(CvSlice slice, CvMemStorage storage)
785        {
786            return Cv.SeqSlice(this, slice, storage);
787        }
788#if LANG_JP
789        /// <summary>
790        /// シーケンススライスのための別のヘッダを作成する (cvSeqSlice).
791        /// </summary>
792        /// <param name="slice">抽出するシーケンスの一部分</param>
793        /// <param name="storage">新しいシーケンスヘッダとコピーされたデータ(もしデータがあれば)を保存する出力ストレージ. nullの場合,この関数は入力シーケンスに含まれるストレージを使用する</param>
794        /// <param name="copy_data">抽出されたスライスの要素をコピーするかしないかを示すフラグ</param>
795        /// <returns></returns>
796#else
797        /// <summary>
798        /// Makes separate header for the sequence slice (cvSeqSlice).
799        /// </summary>
800        /// <param name="slice">The part of the sequence to extract. </param>
801        /// <param name="storage">The destination storage to keep the new sequence header and the copied data if any. If it is null, the function uses the storage containing the input sequence. </param>
802        /// <param name="copy_data">The flag that indicates whether to copy the elements of the extracted slice (copy_data=true) or not (copy_data=false) </param>
803        /// <returns></returns>
804#endif
805        public virtual CvSeq Slice(CvSlice slice, CvMemStorage storage, bool copy_data)
806        {
807            return Cv.SeqSlice(this, slice, storage, copy_data);
808        }
809        #endregion
810        #region Sort
811#if LANG_JP
812        /// <summary>
813        /// シーケンスの要素を,指定した比較関数を用いてソートする (cvSeqSort).
814        /// </summary>
815        /// <param name="func">要素の関係に応じて,負・0・正の値を返す比較関数</param>
816#else
817        /// <summary>
818        /// Sorts sequence element using the specified comparison function (cvSeqSort).
819        /// </summary>
820        /// <param name="func">The comparison function that returns negative, zero or positive value depending on the elements relation (see the above declaration and the example below) - similar function is used by qsort from C runtime except that in the latter userdata is not used </param>
821#endif
822        public virtual void Sort(CvCmpFunc func)
823        {
824            Cv.SeqSort(this, func);
825        }
826        #endregion
827        #region StartAppend
828#if LANG_JP
829        /// <summary>
830        /// シーケンスへのデータ書き込み処理を初期化する (cvStartAppendToSeq).
831        /// </summary>
832        /// <returns>ライタ(Writer)の状態.この関数で初期化される.</returns>
833#else
834        /// <summary>
835        /// Initializes process of writing data to sequence (cvStartAppendToSeq).
836        /// </summary>
837        /// <returns>Writer state; initialized by the function. </returns>
838#endif
839        public CvSeqWriter StartAppend()
840        {
841            CvSeqWriter writer;
842            Cv.StartAppendToSeq(this, out writer);
843            return writer;
844        }
845        #endregion
846        #region StartRead
847#if LANG_JP
848        /// <summary>
849        /// シーケンスからの連続読み出し処理を初期化する (cvStartReadSeq).
850        /// </summary>
851        /// <param name="reader">リーダ(reader)の状態.この関数で初期化される.</param>
852#else
853        /// <summary>
854        /// Initializes process of sequential reading from sequence (cvStartReadSeq).
855        /// </summary>
856        /// <param name="reader">Reader state; initialized by the function. </param>
857#endif
858        public virtual void StartRead(CvSeqReader reader)
859        {
860            Cv.StartReadSeq(this, reader);
861        }
862#if LANG_JP
863        /// <summary>
864        /// シーケンスからの連続読み出し処理を初期化する (cvStartReadSeq).
865        /// </summary>
866        /// <param name="reader">リーダ(reader)の状態.この関数で初期化される.</param>
867        /// <param name="reverse">シーケンス走査方向の指定.reverse が false の場合,リーダは先頭のシーケンス要素に位置する.それ以外は最後の要素に位置する.</param>
868#else
869        /// <summary>
870        /// Initializes process of sequential reading from sequence (cvStartReadSeq).
871        /// </summary>
872        /// <param name="reader">Reader state; initialized by the function. </param>
873        /// <param name="reverse">Determines the direction of the sequence traversal. If reverse is false, the reader is positioned at the first sequence element, otherwise it is positioned at the last element. </param>
874#endif
875        public virtual void StartRead(CvSeqReader reader, bool reverse)
876        {
877            Cv.StartReadSeq(this, reader, reverse);
878        }
879        #endregion
880        #region ToArray
881#if LANG_JP
882        /// <summary>
883        /// シーケンスをメモリ内の連続した一つのブロックにコピーする (cvCvtSeqToArray).
884        /// </summary>
885        /// <typeparam name="T"></typeparam>
886        /// <returns>出力される配列. outされる引数 element と同じ値.</returns>
887#else
888        /// <summary>
889        /// Copies sequence to one continuous block of memory (cvCvtSeqToArray).
890        /// </summary>
891        /// <typeparam name="T"></typeparam>
892        /// <returns></returns>
893#endif
894        public T[] ToArray<T>() where T : struct
895        {
896            T[] elements;
897            return Cv.CvtSeqToArray<T>(this, out elements);
898        }
899#if LANG_JP
900        /// <summary>
901        /// シーケンスをメモリ内の連続した一つのブロックにコピーする (cvCvtSeqToArray).
902        /// </summary>
903        /// <typeparam name="T"></typeparam>
904        /// <param name="slice">配列へコピーするシーケンス内の部分</param>
905        /// <returns>出力される配列. outされる引数 element と同じ値.</returns>
906#else
907        /// <summary>
908        /// Copies sequence to one continuous block of memory (cvCvtSeqToArray).
909        /// </summary>
910        /// <typeparam name="T"></typeparam>
911        /// <param name="slice">The sequence part to copy to the array. </param>
912        /// <returns></returns>
913#endif
914        public T[] ToArray<T>(CvSlice slice) where T : struct
915        {
916            T[] elements;
917            return Cv.CvtSeqToArray<T>(this, out elements, slice);
918        }
919        #endregion
920        #endregion
921
922    }
923}
Note: See TracBrowser for help on using the browser.