Changeset 31159

Show
Ignore:
Timestamp:
03/14/09 02:09:57 (4 years ago)
Author:
schima
Message:

Delaunayが動くまで実装

Location:
lang/cpluspluscli/OpenCvSharp2/trunk
Files:
12 modified

Legend:

Unmodified
Added
Removed

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Core/CvInline.h

    r31149 r31159  
    2424                        return CV_IS_SET_ELEM( ptr.ToPointer() ); 
    2525                } 
     26                [Obsolete] 
    2627                static void CV_NEXT_SEQ_ELEM_( int elem_size, IntPtr reader ) { 
    2728                        CvSeqReader sr = *((CvSeqReader*)reader.ToPointer()); 
    2829                        CV_NEXT_SEQ_ELEM(elem_size, sr); 
    2930                } 
     31                [Obsolete] 
    3032                static void CV_PREV_SEQ_ELEM_( int elem_size, IntPtr reader ) { 
    3133                        CvSeqReader sr = *((CvSeqReader*)reader.ToPointer()); 
    … …  
    6466                        return ::cvSubdiv2DSymEdge(edge); 
    6567                } 
    66                 static CvSubdiv2DEdge cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, Int32 type )      { 
     68                static CvSubdiv2DEdge cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, int type )        { 
    6769                        return ::cvSubdiv2DGetEdge(edge, (CvNextEdgeType)type); 
    6870                } 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Core/WCvQuadEdge2D.h

    r31136 r31159  
    3131                WCvQuadEdge2D(IntPtr ptr) 
    3232                { 
     33                        if(ptr == IntPtr::Zero) { 
     34                                //throw gcnew ArgumentNullException("ptr"); 
     35                        } 
    3336                        this->_ptr = reinterpret_cast<CvQuadEdge2D*>(ptr.ToPointer()); 
    3437                        this->Ptr = IntPtr(ptr); 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Core/WCvSeqReader.h

    r31149 r31159  
    66#pragma once 
    77 
    8 typedef struct CvSeqReader __CvSeqReader; 
    9  
    108namespace KwsmLab { 
    119namespace OpenCvSharp { 
    1210namespace Core 
    1311{ 
     12        struct CvSeqReaderHolder 
     13        { 
     14        public: 
     15                CvSeqReader SeqReader; 
     16 
     17                CvSeqReaderHolder() 
     18                { 
     19                        this->SeqReader = CvSeqReader(); 
     20                } 
     21        }; 
     22 
    1423        /// <summary> 
    1524        /// CvSeq�����[�^��ݎ����߂̃N���X 
    … …  
    1827        { 
    1928        private: 
    20                 __CvSeqReader* _ptr; 
     29                CvSeqReader* _ptr; 
    2130                bool isDisposed; 
    2231 
    … …  
    3443                WCvSeqReader() 
    3544                { 
    36                         this->_ptr = new __CvSeqReader; 
    37                         this->Ptr = IntPtr(ptr); 
     45                        this->_ptr = new struct CvSeqReader; 
     46                        this->Ptr = IntPtr(this->_ptr); 
    3847                        this->isDisposed = false; 
    3948                } 
    … …  
    5362                { 
    5463                        if(!isDisposed){ 
    55                                 delete ptr; 
     64                                delete this->_ptr; 
    5665                                isDisposed = true; 
    5766                        } 
    … …  
    6372                { 
    6473                        if(!isDisposed){ 
    65                                 delete ptr; 
     74                                delete this->_ptr; 
    6675                                isDisposed = true; 
    6776                        } 
    … …  
    6978 
    7079                property int header_size { 
    71                         int get(){ return _ptr->header_size; } 
     80                        int get(){ return this->_ptr->header_size; } 
    7281                }; 
    7382                property IntPtr seq{ 
    74                         IntPtr get(){ return IntPtr(_ptr->seq); } 
     83                        IntPtr get(){ return IntPtr(this->_ptr->seq); } 
    7584                } 
    7685                property IntPtr block{ 
    77                         IntPtr get(){ return IntPtr(_ptr->block); } 
     86                        IntPtr get(){ return IntPtr(this->_ptr->block); } 
    7887                } 
    7988                property IntPtr ptr{ 
    80                         IntPtr get(){ return IntPtr(_ptr->ptr); } 
     89                        IntPtr get(){ return IntPtr(this->_ptr->ptr); } 
     90                        void set(IntPtr value){ _ptr->ptr = (schar*)value.ToPointer(); } 
    8191                } 
    8292                property IntPtr block_min{ 
    83                         IntPtr get(){ return IntPtr(_ptr->block_min); } 
     93                        IntPtr get(){ return IntPtr(this->_ptr->block_min); } 
    8494                } 
    8595                property IntPtr block_max{ 
    86                         IntPtr get(){ return IntPtr(_ptr->block_max); } 
     96                        IntPtr get(){ return IntPtr(this->_ptr->block_max); } 
    8797                } 
    8898                property int delta_index { 
    89                         int get(){ return _ptr->delta_index; } 
     99                        int get(){ return this->_ptr->delta_index; } 
    90100                }; 
    91101                property IntPtr prev_elem{ 
    92                         IntPtr get(){ return IntPtr(_ptr->prev_elem); } 
     102                        IntPtr get(){ return IntPtr(this->_ptr->prev_elem); } 
    93103                } 
    94104        }; 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Test/Program.cs

    r31149 r31159  
    4444        static void Main() 
    4545        { 
     46            /*unsafe 
     47            { 
     48                int i = 100; 
     49                IntPtr ptr1 = new IntPtr(&i); 
     50                IntPtr ptr2 = new IntPtr(ptr1.ToInt32() + 4); 
     51 
     52                i.ToString(); 
     53            }*/ 
     54             
     55            /*using (IplImage image = new IplImage(200, 200, BitDepth.U8, 3)) 
     56            { 
     57                CvPoint[] pts = new CvPoint[] { new CvPoint(10, 10), new CvPoint(100, 100), new CvPoint(50, 100) }; 
     58                image.PolyLine(new CvPoint[][] { pts }, true, CvColor.Red, 1, LineType.AntiAlias, 0); 
     59                using (CvWindow w = new CvWindow(image)) 
     60                { 
     61                    Cv.WaitKey(); 
     62                } 
     63            } 
     64            return;*/ 
    4665            // 画像のアフィン変換 
    4766            //new Test.Affine();                         

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Test/Samples/Delaunay.cs

    r31149 r31159  
    2929                for (int i = 0; i < 200; i++) 
    3030                { 
    31                     CvPoint2D32f fp = new CvPoint2D32f((float)rand.Next(5, rect.Width - 10), (float)rand.Next(5, rect.Height - 10)); 
     31                    CvPoint2D32f fp = new CvPoint2D32f 
     32                    { 
     33                        X = (float)rand.Next(5, rect.Width - 10), 
     34                        Y = (float)rand.Next(5, rect.Height - 10) 
     35                    }; 
    3236                    locate_point(subdiv, fp, img, active_facet_color); 
    3337                    window.Image = img; 
    … …  
    7377                do 
    7478                { 
     79                    //Console.WriteLine(e); 
    7580                    draw_subdiv_edge(img, e, active_color); 
    76                     e = e.GetEdge(NextEdgeType.NextAroundLeft); 
     81                    e = e.GetEdge(NextEdgeType.NextAroundLeft);                     
    7782                } 
    7883                while (e != e0); 
    … …  
    130135                CvPoint idst = new CvPoint(Cv.Round(dst.X), Cv.Round(dst.Y)); 
    131136 
     137                Console.WriteLine("{0} / {1}", iorg, idst); 
    132138                img.Line(iorg, idst, color, 1, LineType.AntiAlias, 0); 
    133139            } 
    … …  
    150156            for (int i = 0; i < total; i++) 
    151157            { 
    152                 CvQuadEdge2D edge = CvQuadEdge2D.FromPtr(reader.CvPtr); 
     158                CvQuadEdge2D edge = CvQuadEdge2D.FromSeqReader(reader); 
     159                //CvQuadEdge2D edge = CvQuadEdge2D.FromPtr(reader.Ptr); 
    153160 
    154161                if (Cv.IS_SET_ELEM(edge)) 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Class/CvQuadEdge2D.cs

    r31149 r31159  
    22using System.Collections.Generic; 
    33using System.Linq; 
     4using System.Runtime.InteropServices; 
    45using System.Text; 
    56 
    … …  
    6869                throw new ArgumentNullException("reader"); 
    6970            } 
    70             return new CvQuadEdge2D(reader.CvPtr); 
     71            return new CvQuadEdge2D(reader.Ptr); 
    7172        } 
    7273 
    … …  
    8586            { 
    8687                    return new CvSubdiv2DEdge((uint)this.CvPtr.ToInt32()); 
     88            //uint value = (uint)Marshal.ReadInt32(this.CvPtr); 
     89            //return new CvSubdiv2DEdge(value); 
    8790            } 
    8891        #endregion 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Class/CvSeqReader.cs

    r31149 r31159  
    127127        { 
    128128            get { return data.ptr; } 
     129            internal set { data.ptr = value; } 
    129130        } 
    130131        /// <summary> 
    … …  
    216217        { 
    217218            T result; 
    218             Cv.PREV_READ_SEQ_ELEM<T>(out result, this); 
     219            Cv.REV_READ_SEQ_ELEM<T>(out result, this); 
    219220            return result; 
    220221        } 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Cv.cs

    r31149 r31159  
    8282        } 
    8383        #endregion 
    84         #region _NEXT_SEQ_ELEM 
     84        #region NEXT_SEQ_ELEM 
    8585        /// <summary> 
    8686        /// 次のシーケンスへ 
    … …  
    8989        /// <param name="reader"></param> 
    9090        public static void NEXT_SEQ_ELEM(int elem_size, CvSeqReader reader) 
    91         { 
     91        {             
    9292            if (reader == null) 
    9393            { 
    9494                throw new ArgumentNullException("reader"); 
    9595            } 
     96            /* 
    9697            CvInline.CV_NEXT_SEQ_ELEM_(elem_size, reader.CvPtr); 
     98            reader.ToString(); 
     99            //*/ 
     100            /* 
     101            #define CV_NEXT_SEQ_ELEM( elem_size, reader )                 \ 
     102            {                                                             \ 
     103                if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \ 
     104                {                                                         \ 
     105                    cvChangeSeqBlock( &(reader), 1 );                     \ 
     106                }                                                         \ 
     107            } 
     108            */ 
     109            ///* 
     110            reader.Ptr = new IntPtr(reader.Ptr.ToInt32() + elem_size); 
     111            if( reader.Ptr.ToInt32() >= reader.BlockMax.ToInt32() )  
     112            { 
     113                CvDll.cvChangeSeqBlock(reader.CvPtr, 1);                 
     114            }  
     115            //*/                                        
    97116        } 
    98117        #endregion 
    … …  
    109128                throw new ArgumentNullException("reader"); 
    110129            } 
    111             CvInline.CV_PREV_SEQ_ELEM_(elem_size, reader.CvPtr); 
     130            //CvInline.CV_PREV_SEQ_ELEM_(elem_size, reader.CvPtr); 
     131            /* 
     132            #define CV_PREV_SEQ_ELEM( elem_size, reader )                \ 
     133            {                                                            \ 
     134                if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \ 
     135                {                                                        \ 
     136                    cvChangeSeqBlock( &(reader), -1 );                   \ 
     137                }                                                        \ 
     138            } 
     139            */ 
     140            reader.Ptr = new IntPtr(reader.Ptr.ToInt32() - elem_size); 
     141            if (reader.Ptr.ToInt32() < reader.BlockMin.ToInt32()) 
     142            { 
     143                CvDll.cvChangeSeqBlock(reader.CvPtr, -1); 
     144            }   
    112145        } 
    113146        #endregion 
    … …  
    139172        } 
    140173        #endregion 
    141         #region PREV_READ_SEQ_ELEM 
     174        #region REV_READ_SEQ_ELEM 
    142175        /// <summary> 
    143176        /// シーケンスの要素を一つ読みだして、読み出しポインタを次へ1つ移動させる 
    … …  
    145178        /// <param name="elem"></param> 
    146179        /// <param name="reader"></param> 
    147         public static void PREV_READ_SEQ_ELEM<T>(out T elem, CvSeqReader reader) where T : struct 
     180        public static void REV_READ_SEQ_ELEM<T>(out T elem, CvSeqReader reader) where T : struct 
    148181        { 
    149182            if (reader == null) 
    … …  
    558591        { 
    559592            return CvInline.cvSubdiv2DGetEdge(edge, (int)type); 
     593 
     594            /* 
     595            Int64 edge64 = Convert.ToInt64(edge.Value); 
     596            IntPtr ptr = (IntPtr)(edge64 & -4); 
     597            CvQuadEdge2D qe = new CvQuadEdge2D(ptr); 
     598            Int64 edgePtr = qe.Next[(edge64 + (int)type) & 3]; 
     599            edgePtr = (edgePtr & -4) + ((edgePtr + ((int)type >> 4)) & 3); 
     600            return new CvSubdiv2DEdge(Convert.ToUInt32(edgePtr)); 
     601            //*/ 
    560602        } 
    561603        #endregion 
    … …  
    574616                throw new ArgumentNullException("subdiv"); 
    575617            } 
    576             CvSubdiv2DEdge e = 0; 
     618            CvSubdiv2DEdge e; 
    577619            IntPtr p = IntPtr.Zero; 
    578620            Subdiv2DPointLocation result = CvDll.cvSubdiv2DLocate(subdiv.CvPtr, pt, out e, ref p); 
    … …  
    594636                throw new ArgumentNullException("subdiv"); 
    595637            } 
     638            CvSubdiv2DEdge e; 
    596639            IntPtr p = vertex.CvPtr; 
    597             Subdiv2DPointLocation result = CvDll.cvSubdiv2DLocate(subdiv.CvPtr, pt, out edge, ref p); 
     640            Subdiv2DPointLocation result = CvDll.cvSubdiv2DLocate(subdiv.CvPtr, pt, out e, ref p); 
     641            edge = e; 
    598642            if (p == IntPtr.Zero) 
    599643            { 
    … …  
    12111255                } 
    12121256                // メモリ確保 
    1213                 gch[i] = GCHandle.Alloc(pts[i]); 
     1257                gch[i] = GCHandle.Alloc(pts[i], GCHandleType.Pinned); 
    12141258                ptsPtr[i] = gch[i].AddrOfPinnedObject(); 
    12151259            } 
    … …  
    18131857        public static void StartReadSeq(CvSeq seq, CvSeqReader reader) 
    18141858        { 
    1815             StartReadSeq(seq, reader); 
     1859            StartReadSeq(seq, reader, false); 
    18161860        } 
    18171861        /// <summary> 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/CvDll.cs

    r31149 r31159  
    6060 
    6161        #region CxCore 
     62        [DllImport(DLL_CXCORE)] 
     63        public static extern void cvChangeSeqBlock( IntPtr reader, Int32 direction ); 
    6264        [DllImport(DLL_CXCORE)] 
    6365        public static extern void cvCircle(IntPtr img, CvPoint center, Int32 radius, CvScalar color, Int32 thickness, [MarshalAs(UnmanagedType.U4)] LineType line_type, Int32 shift); 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Struct/CvPoint.cs

    r31077 r31159  
    3939        } 
    4040 
    41         /// <summary> 
    42         /// Equalsのオーバーライド 
    43         /// </summary> 
    44         /// <param name="obj"></param> 
    45         /// <returns></returns> 
    46         public override bool Equals(object obj) 
    47         { 
    48             return base.Equals(obj); 
    49         } 
     41         
    5042        /// <summary> 
    5143        /// 指定したCvPointの座標と等しければtrueを返す  
    … …  
    7971 
    8072        /// <summary> 
     73        /// Equalsのオーバーライド 
     74        /// </summary> 
     75        /// <param name="obj"></param> 
     76        /// <returns></returns> 
     77        public override bool Equals(object obj) 
     78        { 
     79            return base.Equals(obj); 
     80        } 
     81        /// <summary> 
    8182        /// GetHashCodeのオーバーライド 
    8283        /// </summary> 
    … …  
    8687            return X.GetHashCode() + Y.GetHashCode(); 
    8788        } 
     89        /// <summary> 
     90        /// 文字列形式を返す  
     91        /// </summary> 
     92        /// <returns>文字列形式</returns> 
     93        public override string ToString() 
     94        { 
     95            return string.Format("CvPoint (x:{0} y:{1})", X, Y); 
     96        } 
    8897    } 
    8998} 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Struct/CvPoint2D32f.cs

    r31136 r31159  
    7777        } 
    7878 
    79         /// <summary> 
    80         /// Equalsのオーバーライド 
    81         /// </summary> 
    82         /// <param name="obj"></param> 
    83         /// <returns></returns> 
    84         public override bool Equals(object obj) 
    85         { 
    86             return base.Equals(obj); 
    87         } 
     79         
    8880        /// <summary> 
    8981        /// 指定したCvPoint2D32fの座標と等しければtrueを返す  
    … …  
    117109 
    118110        /// <summary> 
     111        /// Equalsのオーバーライド 
     112        /// </summary> 
     113        /// <param name="obj"></param> 
     114        /// <returns></returns> 
     115        public override bool Equals(object obj) 
     116        { 
     117            return base.Equals(obj); 
     118        } 
     119        /// <summary> 
    119120        /// GetHashCodeのオーバーライド 
    120121        /// </summary> 
    … …  
    124125            return X.GetHashCode() + Y.GetHashCode(); 
    125126        } 
     127        /// <summary> 
     128        /// 文字列形式を返す  
     129        /// </summary> 
     130        /// <returns>文字列形式</returns> 
     131        public override string ToString() 
     132        { 
     133            return string.Format("CvPoint2D32f (x:{0} y:{1})", X, Y); 
     134        } 
    126135    } 
    127136} 

  • lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Struct/CvSubdiv2DEdge.cs

    r31149 r31159  
    6060        /// 入力された辺に関連する辺の一つを返す (Subdiv2DGetEdge相当) 
    6161        /// </summary> 
    62         /// <param name="edge">細分割平面の辺の一つ（quad-edge表現ではない）</param> 
    6362        /// <param name="type">戻り値とする辺の条件</param> 
    6463        /// <returns>与えられた辺に関連する辺の一つ</returns> 
    … …  
    10099            public CvSubdiv2DEdge RotateEdge( RotateEdgeFlag rotate ) 
    101100            { 
    102                     return Cv.Subdiv2DRotateEdge(this.Value, rotate); 
     101                    return Cv.Subdiv2DRotateEdge(this, rotate); 
    103102            } 
    104103        #endregion 
    105104        #endregion 
     105 
     106 
     107        public override string ToString() 
     108        { 
     109            return string.Format("CvSubdiv2DEdge({0})", Value); 
     110        } 
    106111    } 
    107112}