Changeset 30907

Show
Ignore:
Timestamp:
03/07/09 13:17:29 (4 years ago)
Author:
schima
Message:

DisposableObjectによりリソース解放処理を統一化

Location:
lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp
Files:
1 added
33 modified

Legend:

Unmodified
Added
Removed
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CV.cpp

    r30899 r30907  
    77137713        { 
    77147714                CHECK_NULL(capture); 
    7715                 capture->~CvCapture(); 
     7715                delete capture; 
    77167716        } 
    77177717        #pragma endregion 
     
    77377737        { 
    77387738                CHECK_NULL(fs); 
    7739                 fs->Close(); 
     7739                delete fs; 
    77407740        } 
    77417741        #pragma endregion 
     
    77487748        { 
    77497749                CHECK_NULL(cascade); 
    7750                 cascade->Release(); 
     7750                delete cascade; 
    77517751        } 
    77527752        #pragma endregion 
     
    77607760        { 
    77617761                CHECK_NULL(hist); 
    7762                 hist->Release(); 
     7762                delete hist; 
    77637763        } 
    77647764        #pragma endregion 
     
    77717771        { 
    77727772                CHECK_NULL(image); 
    7773                 image->Release(); 
     7773                delete image; 
    77747774        } 
    77757775        #pragma endregion  
     
    77937793        { 
    77947794                CHECK_NULL(kalman); 
    7795                 kalman->Release(); 
     7795                delete kalman; 
    77967796        } 
    77977797        #pragma endregion  
     
    78047804        { 
    78057805                CHECK_NULL(mat); 
    7806                 mat->Release(); 
     7806                delete mat; 
    78077807        } 
    78087808        #pragma endregion  
     
    78177817        { 
    78187818                CHECK_NULL(storage); 
    7819                 storage->Release(); 
     7819                delete storage; 
    78207820        } 
    78217821        #pragma endregion 
     
    78287828        { 
    78297829                CHECK_NULL(state); 
    7830                 state->Release(); 
     7830                delete state; 
    78317831        } 
    78327832        #pragma endregion  
     
    78397839        { 
    78407840                CHECK_NULL(state); 
    7841                 state->Release(); 
     7841                delete state; 
    78427842        } 
    78437843        #pragma endregion  
     
    78507850        { 
    78517851                CHECK_NULL(element); 
    7852                 element->Release(); 
     7852                delete element; 
    78537853        } 
    78547854        #pragma endregion  
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvArr.cpp

    r30899 r30907  
    1919        /// デフォルトコンストラクタ 
    2020        /// </summary> 
    21         CvArr::CvArr(void) 
     21        CvArr::CvArr(void) : DisposableObject() 
    2222        { 
    2323                this->ptr = NULL; 
    24                 this->isDisposed = false; 
    25                 this->isEnabledDispose = true; 
    2624        } 
    2725        /// <summary> 
     
    2927        /// </summary> 
    3028        /// <param name="isEnabledDispose">GCで解放するならtrue</param> 
    31         CvArr::CvArr(Boolean isEnabledDispose) 
     29        CvArr::CvArr(Boolean isEnabledDispose) : DisposableObject(isEnabledDispose) 
    3230        { 
    3331                this->ptr = NULL; 
    34                 this->isDisposed = false; 
    35                 this->isEnabledDispose = isEnabledDispose; 
    3632        } 
    3733        /// <summary> 
     
    3935        /// </summary> 
    4036        /// <param name="ptr">元データポインタ</param> 
    41         CvArr::CvArr(void* ptr) 
     37        CvArr::CvArr(void* ptr) : DisposableObject() 
    4238        { 
    4339                if(ptr == NULL){ 
     
    4541                } 
    4642                this->ptr = ptr; 
    47                 this->isDisposed = false; 
    48                 this->isEnabledDispose = true; 
    4943        } 
    5044        /// <summary> 
     
    5347        /// <param name="ptr">元データポインタ</param> 
    5448        /// <param name="isEnabledDispose">GCで解放するならtrue</param> 
    55         CvArr::CvArr(void* ptr, Boolean isEnabledDispose) 
     49        CvArr::CvArr(void* ptr, Boolean isEnabledDispose) : DisposableObject(isEnabledDispose) 
    5650        { 
    5751                if(ptr == NULL){ 
     
    5953                } 
    6054                this->ptr = ptr; 
    61                 this->isDisposed = false; 
    62                 this->isEnabledDispose = isEnabledDispose; 
    6355        } 
    6456 
    65         /// <summary> 
    66         /// ファイナライザ 
    67         /// </summary> 
    68         CvArr::!CvArr(void) 
    69         { 
    70                 if(isEnabledDispose && !isDisposed){ 
    71                         Release(); 
    72                         isDisposed = true; 
    73                 } 
    74         } 
    75         /// <summary> 
    76         /// 解放 
    77         /// </summary> 
    78         CvArr::~CvArr(void) 
    79         { 
    80                 if(isEnabledDispose && !isDisposed){ 
    81                         Release(); 
    82                         isDisposed = true; 
    83                 } 
    84         } 
    8557        /// <summary> 
    8658        /// CvArr -> void* への明示的なキャスト 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvArr.h

    r29928 r30907  
    3737        /// これらを引数にとる関数を記述するための仮引数として利用される。 
    3838        /// </summary> 
    39         public ref class CvArr abstract : public IDisposable, public ICvObject 
     39        public ref class CvArr abstract : public DisposableObject, public ICvObject 
    4040        { 
    4141        private: 
     
    4343        protected:       
    4444                void* ptr; 
    45                 Boolean isDisposed; 
    46                 Boolean isEnabledDispose; 
    4745 
    4846        internal: 
     
    5957                        virtual void set(void* value){ ptr = value; } 
    6058                } 
    61                 /// <summary> 
    62                 /// リソースの解放を行う。サブクラスで適宜再定義すべし。 
    63                 /// </summary> 
    64                 /// <remarks> 
    65                 /// C++/CLIはDisposeがabstractにできないようなので仕方なくこんなメソッドを用意。 
    66                 /// 2重解放はされないようになっているので、解放処理のみを書けばよい。 
    67                 /// 傍目にはDisposeで解放してるように見える。 
    68                 /// </remarks> 
    69                 virtual void Release(void) abstract;     
    70  
    71         public: 
    72                 !CvArr( void ); 
    73                 ~CvArr( void ); 
    74                  
     59 
     60        public:          
    7561                static explicit operator void*( N::CvArr^ obj );         
    7662                static explicit operator IntPtr( N::CvArr^ obj );        
     
    9076                        Int32 get(void){ return IntPtr::Size; } 
    9177                } 
    92                 /// <summary> 
    93                 /// リソースが解放済みかどうかを取得する 
    94                 /// </summary> 
    95                 virtual property Boolean IsDisposed{ 
    96                         public:         Boolean get(){ return isDisposed; } 
    97                         protected:      void set(Boolean value){ isDisposed = value;} 
    98                 } 
    99                 /// <summary> 
    100                 /// GCによる自動的な解放を行うかどうかを取得・設定する 
    101                 /// </summary> 
    102                 virtual property Boolean IsEnabledDispose{ 
    103                         bool get(){ return isEnabledDispose; } 
    104                         void set(Boolean value){ isEnabledDispose = value;} 
    105                 } 
     78 
    10679                /// <summary> 
    10780                /// 配列の次元数を取得する.  
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvCapture.cpp

    r30899 r30907  
    8888 
    8989        /// <summary> 
    90         /// ファイナライザ 
     90        /// 解放処理 
    9191        /// </summary> 
    92         CvCapture::!CvCapture(void) 
     92        void CvCapture::Release(void) 
    9393        { 
    94                 if(!isDisposed){ 
    95                         isDisposed = true; 
    96                         ::CvCapture* pp = this->Ptr; 
    97                         ::cvReleaseCapture(&pp); 
    98                 } 
    99         } 
    100         /// <summary> 
    101         /// 解放 
    102         /// </summary> 
    103         CvCapture::~CvCapture(void) 
    104         { 
    105                 CvCapture::!CvCapture(); 
     94                ::CvCapture* pp = this->Ptr; 
     95                ::cvReleaseCapture(&pp); 
    10696        } 
    10797 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvCapture.h

    r27019 r30907  
    2727        /// ビデオキャプチャ 
    2828        /// </summary> 
    29         public ref class CvCapture : IDisposable 
     29        public ref class CvCapture : public DisposableObject, public ICvObject 
    3030        { 
    3131        private: 
    3232                ::CvCapture* ptr; 
    33                 Boolean isDisposed; 
    3433                CaptureType captureType; 
     34 
     35        protected: 
     36                virtual void Release( void ) override;   
     37 
    3538        internal: 
    36                 CvCapture(::CvCapture* ptr); 
     39                CvCapture(::CvCapture* ptr);             
    3740                /// <summary> 
    3841                /// 元データポインタ(CvCapture*) 
     
    4144                        ::CvCapture* get(void){ return this->ptr; } 
    4245                } 
     46 
    4347        public: 
    4448                CvCapture( String^ filename ); 
    4549                CvCapture( Int32 index ); 
    4650                CvCapture( N::CaptureDevice device ); 
    47                 !CvCapture( void); 
    48                 ~CvCapture( void); 
    4951 
    5052                static N::CvCapture^ FromFile( String^ filename ); 
    5153                static N::CvCapture^ FromCamera( Int32 index ); 
    52                 static N::CvCapture^ FromCamera( N::CaptureDevice device ); 
     54                static N::CvCapture^ FromCamera( N::CaptureDevice device );              
    5355 
    5456                /// <summary> 
    55                 /// リソースが解放済みかどうか 
     57                /// OpenCVのネイティブデータポインタを取得する 
    5658                /// </summary> 
    57                 property Boolean IsDisposed{ 
    58                         public:         bool get(){ return isDisposed; } 
    59                         private:        void set(bool value){ isDisposed = value;} 
     59                virtual property IntPtr CvPtr{ 
     60                        IntPtr get(void){ return (IntPtr)ptr; } 
    6061                } 
    6162                /// <summary> 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvFileStorage.cpp

    r30899 r30907  
    3535        void CvFileStorage::Close(void) 
    3636        { 
    37                 Release(); 
    38         } 
    39         /// <summary> 
    40         /// リソースの解放を行う 
    41         /// </summary> 
    42         void CvFileStorage::Release(void) 
    43         { 
    4437                if(!isDisposed){ 
    45                         __CvFileStorage* _ptr = ptr; 
    46                         cvReleaseFileStorage( &_ptr ); 
     38                        Release(); 
    4739                        isDisposed = true; 
    4840                } 
    4941        } 
    50  
    51         /// <summary> 
    52         /// ファイナライザ 
    53         /// </summary> 
    54         CvFileStorage::!CvFileStorage(void) 
    55         { 
    56                 Release(); 
    57         } 
    58         /// <summary> 
    59         /// 解放 
    60         /// </summary> 
    61         CvFileStorage::~CvFileStorage(void) 
    62         { 
    63                 Release(); 
     42        /// <summary> 
     43        /// リソースの解放を行う 
     44        /// </summary> 
     45        void CvFileStorage::Release(void) 
     46        { 
     47                __CvFileStorage* _ptr = ptr; 
     48                cvReleaseFileStorage( &_ptr ); 
    6449        } 
    6550        #pragma endregion 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvFileStorage.h

    r30662 r30907  
    2727        /// CXCoreは,XML(http://www.w3c.org/XML)や YAML (http://www.yaml.org)形式のデータの読み書きが可能である. 
    2828        /// </summary> 
    29         public ref class CvFileStorage : public IDisposable, public ICvObject 
     29        public ref class CvFileStorage : public DisposableObject, public ICvObject 
    3030        { 
    3131        private: 
    3232                __CvFileStorage* ptr; 
    33                 Boolean isDisposed; 
     33 
     34        protected: 
     35                virtual void Release( void ) override; 
    3436 
    3537        internal: 
     
    4345 
    4446        public: 
    45                 CvFileStorage( String^ filename, N::CvMemStorage^ memstorage, FileStorageMode flags ); 
    46                 !CvFileStorage( void ); 
    47                 ~CvFileStorage( void ); 
     47                CvFileStorage( String^ filename, N::CvMemStorage^ memstorage, FileStorageMode flags );           
    4848 
    4949                /// <summary> 
     
    7979                Double ReadRealByName(N::CvFileNode^ map, String^ name, Double default_value ); 
    8080                String^ ReadStringByName( N::CvFileNode^ map, String^ name ); 
    81                 String^ ReadStringByName( N::CvFileNode^ map, String^ name, String^ default_value ); 
    82                 void Release( void ); 
     81                String^ ReadStringByName( N::CvFileNode^ map, String^ name, String^ default_value );             
    8382                void StartNextStream( void ); 
    8483                void StartWriteStruct( String^ name, NodeType struct_flags ); 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvFont.cpp

    r17367 r30907  
    2525                } 
    2626                this->Ptr = ptr; 
    27                 this->Disposed = false; 
    2827        }; 
    2928        /// <summary> 
     
    3332        { 
    3433                this->Ptr = new __CvFont; 
    35                 this->Disposed = false; 
    3634        }; 
    3735        /// <summary> 
     
    4846                this->Ptr = new __CvFont; 
    4947                ::cvInitFont(this->Ptr, (int)font_face, hscale, vscale, shear, thickness, (int)line_type); 
    50                 this->Disposed = false; 
    5148        } 
    5249        /// <summary> 
     
    6259                this->Ptr = new __CvFont; 
    6360                ::cvInitFont(this->Ptr, (int)font_face, hscale, vscale, shear, thickness); 
    64                 this->Disposed = false; 
    6561        } 
    6662        /// <summary> 
     
    7571                this->Ptr = new __CvFont; 
    7672                ::cvInitFont(this->Ptr, (int)font_face, hscale, vscale, shear); 
    77                 this->Disposed = false; 
    7873        } 
    7974        /// <summary> 
     
    8782                this->Ptr = new __CvFont; 
    8883                ::cvInitFont(this->Ptr, (int)font_face, hscale, vscale); 
    89                 this->Disposed = false; 
    9084        } 
    9185        /// <summary> 
     
    9892                this->Ptr = new __CvFont; 
    9993                ::cvInitFont( this->Ptr, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA ); 
    100                 this->Disposed = false;          
    10194        } 
    10295        /// <summary> 
     
    108101                this->Ptr = new __CvFont; 
    109102                ::cvInitFont( this->Ptr, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, 1, CV_AA ); 
    110                 this->Disposed = false; 
    111103                 
    112104        } 
     105 
    113106        /// <summary> 
    114         /// デストラクタ 
     107        /// 解放処理 
    115108        /// </summary> 
    116         CvFont::!CvFont() 
     109        void CvFont::Release() 
    117110        { 
    118                 if(!this->Disposed){ 
    119                         this->Disposed = true; 
    120                         delete this->Ptr; 
    121                 } 
     111                delete this->Ptr; 
    122112        }; 
    123         /// <summary> 
    124         /// ファイナライザ 
    125         /// </summary> 
    126         CvFont::~CvFont() 
    127         { 
    128                 CvFont::!CvFont(); 
    129         }; 
    130  
    131113 
    132114} 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvFont.h

    r17367 r30907  
    2222        /// フォント 
    2323        /// </summary> 
    24         public ref class CvFont : public IDisposable, public ICvObject 
     24        public ref class CvFont : public DisposableObject, public ICvObject 
    2525        { 
    26         private: 
    27                 bool disposed; 
     26        protected: 
     27                virtual void Release( void ) override; 
    2828 
    2929        internal: 
     
    4242                CvFont( Double scale, Int32 thickness ); 
    4343                CvFont( Double scale ); 
    44                 !CvFont(); 
    45                 ~CvFont(); 
    4644 
    4745                /// <summary> 
     
    5755                virtual property Int32 SizeOf{ 
    5856                        Int32 get(void){ return sizeof(*Ptr); }  
    59                 } 
    60                 /// <summary> 
    61                 /// リソースが解放済みかどうか 
    62                 /// </summary> 
    63                 property bool Disposed{ 
    64                         public:         bool get(){ return disposed; } 
    65                         private:        void set(bool value){ disposed = value;} 
    6657                } 
    6758                /// <summary> 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvHaarClassifierCascade.cpp

    r30899 r30907  
    6363                ::cvReleaseHaarClassifierCascade(&p); 
    6464        }        
    65         /// <summary> 
    66         /// �t�@�C�i���C�U 
    67         /// </summary> 
    68         CvHaarClassifierCascade::!CvHaarClassifierCascade(void) 
    69         { 
    70                 if(!isDisposed){ 
    71                         Release(); 
    72                         isDisposed = true; 
    73                 } 
    74         } 
    75         /// <summary> 
    76         /// ���\�[�X�̉� 
    77         /// </summary> 
    78         CvHaarClassifierCascade::~CvHaarClassifierCascade(void) 
    79         { 
    80                 if(!isDisposed){ 
    81                         Release(); 
    82                         isDisposed = true; 
    83                 } 
    84         } 
    8565        #pragma endregion 
    8666 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvHaarClassifierCascade.h

    r22982 r30907  
    2323        /// �i�K���ފ��J�X�P�[�h�܂��͖� 
    2424        /// </summary> 
    25         public ref class CvHaarClassifierCascade : public IDisposable, public ICvObject 
     25        public ref class CvHaarClassifierCascade : public DisposableObject, public ICvObject 
    2626        { 
    2727        private: 
    2828                __CvHaarClassifierCascade* ptr; 
    29                 bool isDisposed; 
     29 
     30        protected: 
     31                virtual void Release( void ) override; 
    3032 
    3133        internal: 
     
    3840                } 
    3941                CvHaarClassifierCascade(__CvHaarClassifierCascade* ptr); 
    40                 void Release(void); 
    4142                 
    4243        public: 
    4344                static N::CvHaarClassifierCascade^ FromPtr( IntPtr ptr ); 
    4445                static N::CvHaarClassifierCascade^ FromFile( String^ filename ); 
    45                 !CvHaarClassifierCascade(void); 
    46                 ~CvHaarClassifierCascade(void); 
    4746 
    4847                #pragma region �v���p�e�B 
     
    5857                virtual property Int32 SizeOf{ 
    5958                        Int32 get(void){ return sizeof(*ptr); }  
    60                 } 
    61                 /// <summary> 
    62                 /// ���\�[�X����ς݂��ǂ��� 
    63                 /// </summary> 
    64                 property bool IsDisposed{ 
    65                         public:         bool get(){ return isDisposed; } 
    66                         protected:      void set(bool value){ isDisposed = value;} 
    6759                } 
    6860 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvHistogram.cpp

    r30899 r30907  
    2828                pin_ptr<int> sizes_ptr = &dims[0]; 
    2929                this->ptr = ::cvCreateHist(dims->Length, sizes_ptr, (int)type); 
    30                 this->isDisposed = false; 
    3130                this->type = type; 
    3231        } 
     
    4746                        SetBinRanges(ranges); 
    4847                } 
    49                 this->isDisposed = false; 
    5048                this->type = type; 
    5149        } 
     
    7270                        SetBinRanges(ranges, uniform); 
    7371                } 
    74                 this->isDisposed = false; 
    7572                this->type = type; 
    7673        } 
     
    8380                CHECK_NULL(ptr); 
    8481                this->ptr = ptr; 
    85                 this->isDisposed = false; 
    86         } 
    87  
    88         /// <summary> 
    89         /// ファイナライザ 
    90         /// </summary> 
    91         CvHistogram::!CvHistogram(void) 
    92         { 
    93                 Release(); 
    94         } 
    95         /// <summary> 
    96         /// 解放 
    97         /// </summary> 
    98         CvHistogram::~CvHistogram(void) 
    99         {        
    100                 Release(); 
    10182        } 
    10283        /// <summary> 
     
    10586        void CvHistogram::Release(void) 
    10687        { 
    107                 if(!isDisposed){ 
    108                         __CvHistogram* _ptr = this->ptr; 
    109                         ::cvReleaseHist(&_ptr); 
    110                         isDisposed = true; 
    111                 } 
     88                __CvHistogram* _ptr = this->ptr; 
     89                ::cvReleaseHist(&_ptr); 
    11290        } 
    11391 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvHistogram.h

    r22982 r30907  
    2323        /// 多次元ヒストグラムの構造体 
    2424        /// </summary> 
    25         public ref class CvHistogram : public IDisposable, public ICvObject 
     25        public ref class CvHistogram : public DisposableObject, public ICvObject 
    2626        { 
    2727        private: 
    2828                __CvHistogram* ptr; 
    2929                HistogramFormat type; 
    30                 Boolean isDisposed; 
     30 
     31        protected: 
     32                virtual void Release( void ) override; 
    3133 
    3234        internal: 
     
    3739                        __CvHistogram* get(void){ return (__CvHistogram*)this->ptr; } 
    3840                } 
    39                 CvHistogram( __CvHistogram* ptr );               
    40                 void Release();          
     41                CvHistogram( __CvHistogram* ptr );                               
    4142 
    4243        public: 
     
    4445                CvHistogram( array<Int32>^ dims, HistogramFormat type, array<array<Single>^>^ ranges ); 
    4546                CvHistogram( array<Int32>^ dims, HistogramFormat type, array<array<Single>^>^ ranges, Boolean uniform ); 
    46                 !CvHistogram( void ); 
    47                 ~CvHistogram( void ); 
    4847                static N::CvHistogram^ FromPtr( IntPtr ptr ); 
    4948                 
    50                 #pragma region プロパティ 
    51                 /// <summary> 
    52                 /// リソースが解放済みかどうかを取得する 
    53                 /// </summary> 
    54                 property Boolean IsDisposed{ 
    55                         public:         bool get(){ return isDisposed; } 
    56                         protected:      void set(bool value){ isDisposed = value; } 
    57                 } 
     49                #pragma region プロパティ} 
    5850                /// <summary> 
    5951                /// OpenCVのネイティブデータポインタを取得する 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvKalman.cpp

    r30899 r30907  
    2323        { 
    2424                this->ptr = ptr; 
    25                 this->isDisposed = false; 
    2625        } 
    2726        /// <summary> 
     
    3332        { 
    3433                this->ptr = ::cvCreateKalman(dynam_params, measure_params); 
    35                 this->isDisposed = false; 
    3634        } 
    3735        /// <summary> 
     
    4442        { 
    4543                this->ptr = ::cvCreateKalman(dynam_params, measure_params, control_params); 
    46                 this->isDisposed = false; 
    4744        } 
    4845 
    49         /// <summary> 
    50         /// �t�@�C�i���C�U 
    51         /// </summary> 
    52         CvKalman::!CvKalman(void) 
    53         { 
    54                 if(!isDisposed){ 
    55                         Release(); 
    56                         isDisposed = true; 
    57                 } 
    58         } 
    59         /// <summary> 
    60         /// �� 
    61         /// </summary> 
    62         CvKalman::~CvKalman(void) 
    63         { 
    64                 if(!isDisposed){ 
    65                         Release(); 
    66                         isDisposed = true; 
    67                 } 
    68         } 
    6946        /// <summary> 
    7047        /// ���\�[�X�̉� 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvKalman.h

    r22982 r30907  
    2121        /// �J���}���t�B���^�� 
    2222        /// </summary> 
    23         public ref class CvKalman : public ICvObject, public IDisposable 
     23        public ref class CvKalman : public DisposableObject, public IDisposable 
    2424        { 
    2525        private: 
     
    2828                /// </summary> 
    2929                __CvKalman* ptr; 
    30                 /// <summary> 
    31                 /// ��ς݂��ǂ��� 
    32                 /// </summary> 
    33                 Boolean isDisposed; 
     30 
     31        protected: 
     32                virtual void Release( void ) override; 
    3433 
    3534        internal:                
     
    4241                } 
    4342                CvKalman(__CvKalman* ptr); 
    44                 void Release();          
    4543 
    4644        public: 
    47                 static N::CvKalman^ FromPtr( IntPtr ptr ); 
     45                static N::CvKalman^ FromPtr( IntPtr ptr );               
    4846 
    4947                #pragma region �v���p�e�B 
     
    6058                        Int32 get(void){ return sizeof(*ptr); }  
    6159                } 
    62                 /// <summary> 
    63                 /// ���\�[�X����ς݂��ǂ����������         /// </summary> 
    64                 property Boolean IsDisposed{ 
    65                         public:         bool get(){ return isDisposed; } 
    66                         protected:      void set(bool value){ isDisposed = value; } 
    67                 } 
    6860 
    6961                /// <summary> 
     
    242234                CvKalman( Int32 dynam_params, Int32 measure_params ); 
    243235                CvKalman( Int32 dynam_params, Int32 measure_params, Int32 control_params ); 
    244                 !CvKalman( void ); 
    245                 ~CvKalman( void ); 
    246236 
    247237                #pragma region ���\�b�h 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvMat.h

    r30662 r30907  
    3535                PtrArray<Double>^ dataArrayDouble; 
    3636 
     37        protected: 
     38                virtual void Release( void ) override; 
     39 
    3740        internal:                
    3841                /// <summary> 
     
    4649                CvMat( __CvMat* ptr ); 
    4750                CvMat( __CvMat* ptr, Boolean isEnabledDispose ); 
    48                 virtual void Release( void ) override;           
     51 
    4952 
    5053        public:          
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvMatND.h

    r17367 r30907  
    2222        public ref class CvMatND : public CvArr//, public ICvArr<CvMatND^> 
    2323        { 
     24        protected: 
     25                virtual void Release( void ) override; 
     26 
    2427        internal:                
    2528                /// <summary> 
     
    3336                CvMatND(__CvMatND* ptr); 
    3437                CvMatND(__CvMatND* ptr, Boolean isEnabledDispose); 
    35                 virtual void Release(void) override; 
    3638 
    3739        public: 
     40 
     41                #pragma region �v���p�e�B 
    3842                /// <summary> 
    3943                /// ���f�[�^�|�C���^�̃o�C�g�T�C�Y�A 
     
    6367                        Int32 get(void) new{ return MatNDPtr->dims; } 
    6468                } 
     69                #pragma endregion 
    6570        }; 
    6671} 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvMemStorage.cpp

    r30899 r30907  
    2525        { 
    2626                this->ptr = ::cvCreateMemStorage(); 
    27                 this->isDisposed = false; 
    2827        } 
    2928        /// <summary> 
     
    3534        { 
    3635                this->ptr = ::cvCreateMemStorage(block_size); 
    37                 this->isDisposed = false; 
    3836        } 
    3937        /// <summary> 
     
    4442        { 
    4543                this->ptr = ptr; 
    46                 this->isDisposed = false; 
    4744        } 
    4845 
    49         /// <summary> 
    50         /// ファイナライザ 
    51         /// </summary> 
    52         CvMemStorage::!CvMemStorage(void) 
    53         { 
    54                 if(!isDisposed){ 
    55                         Release(); 
    56                         isDisposed = true; 
    57                 } 
    58         } 
    59         /// <summary> 
    60         /// 解放 
    61         /// </summary> 
    62         CvMemStorage::~CvMemStorage(void) 
    63         { 
    64                 if(!isDisposed){ 
    65                         Release(); 
    66                         isDisposed = true; 
    67                 } 
    68         } 
    6946        /// <summary> 
    7047        /// リソースの解放 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvMemStorage.h

    r26033 r30907  
    1818        /// 動的に拡張可能なメモリストレージ 
    1919        /// </summary> 
    20         public ref class CvMemStorage : public IDisposable, public ICvObject 
     20        public ref class CvMemStorage : public DisposableObject, public ICvObject 
    2121        { 
    2222        private: 
    2323                __CvMemStorage* ptr; 
    24                 Boolean isDisposed; 
     24 
     25        protected: 
     26                virtual void Release( void ) override; 
     27 
    2528        internal: 
    2629                /// <summary> 
     
    2932                property __CvMemStorage* Ptr{ 
    3033                        __CvMemStorage* get(void){ return (__CvMemStorage*)this->ptr; } 
    31                 } 
    32                 void Release(); 
     34                }                
    3335                CvMemStorage( __CvMemStorage* ptr ); 
    3436 
     
    3638                CvMemStorage( void ); 
    3739                CvMemStorage( Int32 block_size );                
    38                 !CvMemStorage( void ); 
    39                 ~CvMemStorage( void ); 
    4040                static N::CvMemStorage^ FromPtr( IntPtr ptr ); 
    4141 
     
    4444                N::CvMemStorage^ CreateChild( void ); 
    4545                 
    46                 /// <summary> 
    47                 /// リソースが解放済みかどうかを取得する 
    48                 /// </summary> 
    49                 property Boolean IsDisposed{ 
    50                         public:         bool get(){ return isDisposed; } 
    51                         protected:      void set(bool value){ isDisposed = value; } 
    52                 } 
    5346                /// <summary> 
    5447                /// OpenCVのネイティブデータポインタを取得する 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvSeq.h

    r26389 r30907  
    2929        public ref class CvSeq : public CvArr , public ICvArr<CvSeq^> 
    3030        { 
     31        protected: 
     32                virtual void Release( void ) override; 
     33 
    3134        internal:                
    3235                /// <summary> 
     
    4043                CvSeq(Boolean isEnabledDispose); 
    4144                CvSeq(__CvSeq* ptr, Boolean isEnabledDispose); 
    42                 CvSeq(void* ptr, Boolean isEnabledDispose); 
    43                 virtual void Release(void) override;             
     45                CvSeq(void* ptr, Boolean isEnabledDispose);      
    4446 
    4547        public:  
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvSet.h

    r22982 r30907  
    2424        public ref class CvSet : public CvSeq//, public ICvArr<CvSet^> 
    2525        { 
     26        protected: 
     27                virtual void Release( void ) override; 
     28 
    2629        internal: 
    2730                /// <summary> 
     
    3336                CvSet(__CvSet* ptr); 
    3437                CvSet(Boolean isEnabledDispose); 
    35                 CvSet(__CvSet* ptr, Boolean isEnabledDispose); 
    36                 virtual void Release(void) override;     
     38                CvSet(__CvSet* ptr, Boolean isEnabledDispose);                   
    3739                 
    3840        public: 
    3941                static N::CvSet^ FromPtr( IntPtr ptr ); 
    4042 
     43                #pragma region �v���p�e�B 
    4144                /// <summary> 
    4245                /// ���f�[�^�|�C���^�̃o�C�g�T�C�Y�A 
     
    5255                        N::CvSetElem^ get(void) { return gcnew N::CvSetElem(SetPtr->free_elems); } 
    5356                } 
     57                #pragma endregion 
    5458        }; 
    5559 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvSparseMat.h

    r17367 r30907  
    2222        public ref class CvSparseMat : public CvArr//, public ICvArr<CvSparseMat^> 
    2323        { 
     24        protected: 
     25                virtual void Release( void ) override; 
     26 
    2427        internal:                
    2528                /// <summary> 
     
    3235                CvSparseMat(Boolean isEnabledDispose); 
    3336                CvSparseMat(__CvSparseMat* ptr); 
    34                 CvSparseMat(__CvSparseMat* ptr, Boolean isEnabledDispose); 
    35                 virtual void Release(void) override; 
     37                CvSparseMat(__CvSparseMat* ptr, Boolean isEnabledDispose);               
    3638 
    3739        public: 
     40 
     41                #pragma region �v���p�e�B 
    3842                /// <summary> 
    3943                /// ���f�[�^�|�C���^�̃o�C�g�T�C�Y�A 
     
    8286                        } 
    8387                } 
     88                #pragma endregion 
    8489        }; 
    8590} 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvStereoBMState.cpp

    r30899 r30907  
    3737 
    3838        /// <summary> 
    39         /// ファイナライザ 
    40         /// </summary> 
    41         CvStereoBMState::!CvStereoBMState( void ) 
    42         { 
    43                 Release(); 
    44         } 
    45         /// <summary> 
    46         /// 解放 
    47         /// </summary> 
    48         CvStereoBMState::~CvStereoBMState( void ) 
    49         { 
    50                 Release(); 
    51         } 
    52         /// <summary> 
    5339        /// リソースの解放を行う 
    5440        /// </summary> 
    5541        void CvStereoBMState::Release( void ) 
    5642        { 
    57                 if(!isDisposed){ 
    58                         __CvStereoBMState* _ptr = ptr; 
    59                         cvReleaseStereoBMState( &_ptr ); 
    60                         isDisposed = true; 
    61                 } 
     43                __CvStereoBMState* _ptr = ptr; 
     44                cvReleaseStereoBMState( &_ptr ); 
    6245        } 
    6346 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvStereoBMState.h

    r30662 r30907  
    1717        /// ブロックマッチングによるステレオマッチングアルゴリズムのための構造体 
    1818        /// </summary> 
    19         public ref class CvStereoBMState : public IDisposable, public ICvObject 
     19        public ref class CvStereoBMState : public DisposableObject, public ICvObject 
    2020        { 
    2121        private: 
    2222                __CvStereoBMState* ptr; 
    23                 Boolean isDisposed; 
     23 
     24        protected: 
     25                virtual void Release( void ) override; 
    2426                 
    2527        internal: 
     
    3638                CvStereoBMState( StereoBMPreset preset ); 
    3739                CvStereoBMState( StereoBMPreset preset, Int32 numberOfDisparities ); 
    38                 ~CvStereoBMState( void ); 
    39                 !CvStereoBMState( void ); 
    4040 
    41                 void Release( void ); 
    4241                void FindStereoCorrespondence( N::CvArr^ left, N::CvArr^ right, N::CvArr^ disparity ); 
    4342 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvStereoGCState.cpp

    r30899 r30907  
    2222 
    2323        /// <summary> 
    24         /// ファイナライザ 
    25         /// </summary> 
    26         CvStereoGCState::!CvStereoGCState( void ) 
    27         { 
    28                 Release(); 
    29         } 
    30         /// <summary> 
    31         /// 解放 
    32         /// </summary> 
    33         CvStereoGCState::~CvStereoGCState( void ) 
    34         { 
    35                 Release(); 
    36         } 
    37         /// <summary> 
    3824        /// リソースの解放を行う 
    3925        /// </summary> 
    4026        void CvStereoGCState::Release( void ) 
    4127        { 
    42                 if(!isDisposed){ 
    43                         __CvStereoGCState* _ptr = ptr; 
    44                         cvReleaseStereoGCState( &_ptr ); 
    45                         isDisposed = true; 
    46                 } 
     28                __CvStereoGCState* _ptr = ptr; 
     29                cvReleaseStereoGCState( &_ptr ); 
    4730        } 
    4831 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvStereoGCState.h

    r30662 r30907  
    1717        /// グラフカットに基づくステレオマッチングのための構造体 
    1818        /// </summary> 
    19         public ref class CvStereoGCState : public IDisposable, public ICvObject 
     19        public ref class CvStereoGCState : public DisposableObject, public ICvObject 
    2020        { 
    2121        private: 
    2222                __CvStereoGCState* ptr; 
    23                 Boolean isDisposed; 
     23 
     24        protected: 
     25                virtual void Release( void ) override; 
    2426                 
    2527        internal: 
     
    3436        public: 
    3537                CvStereoGCState( Int32 numberOfDisparities, Int32 maxIters ); 
    36                 ~CvStereoGCState( void ); 
    37                 !CvStereoGCState( void ); 
    3838 
    39                 void Release( void ); 
    4039                void FindStereoCorrespondence( N::CvArr^ left, N::CvArr^ right, N::CvArr^ dispLeft, N::CvArr^ dispRight ); 
    4140                void FindStereoCorrespondence( N::CvArr^ left, N::CvArr^ right, N::CvArr^ dispLeft, N::CvArr^ dispRight, Boolean useDisparityGuess ); 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvVideoWriter.cpp

    r30899 r30907  
    5353 
    5454        /// <summary> 
    55         /// ファイナライザ 
    56         /// </summary> 
    57         CvVideoWriter::!CvVideoWriter(void) 
    58         { 
    59                 Close(); 
    60         } 
    61         /// <summary> 
    62         /// 解放 
    63         /// </summary> 
    64         CvVideoWriter::~CvVideoWriter(void) 
    65         { 
    66                 Close(); 
    67         } 
    68         /// <summary> 
    6955        /// ビデオファイルへの書き込みを終了する 
    7056        /// </summary> 
     
    7662                        ::cvReleaseVideoWriter(&pp); 
    7763                } 
     64        } 
     65        void CvVideoWriter::Release(void) 
     66        { 
     67                Close(); 
    7868        } 
    7969 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvVideoWriter.h

    r21994 r30907  
    1919        /// AVIビデオを出力するためのライタ 
    2020        /// </summary> 
    21         public ref class CvVideoWriter : IDisposable 
     21        public ref class CvVideoWriter : public DisposableObject 
    2222        { 
    2323        private: 
     
    2828                N::CvSize frame_size; 
    2929                Boolean is_color; 
    30                 Boolean isDisposed; 
     30 
     31        protected: 
     32                virtual void Release( void ) override; 
     33 
    3134        internal: 
    3235                /// <summary> 
     
    3639                        ::CvVideoWriter* get(void){ return this->ptr; } 
    3740                } 
     41 
    3842        public: 
    3943                CvVideoWriter( String^ filename, String^ fourcc, Double fps, N::CvSize frame_size, Boolean is_color ); 
    4044                CvVideoWriter( String^ filename, String^ fourcc, Double fps, N::CvSize frame_size ); 
    41                 !CvVideoWriter(void); 
    42                 ~CvVideoWriter(void); 
     45 
    4346                void Close(void); 
    4447                Int32 WriteFrame(N::IplImage^ image); 
    4548 
    46                 /// <summary> 
    47                 /// リソースが解放済みかどうか 
    48                 /// </summary> 
    49                 property Boolean IsDisposed{ 
    50                         public:         bool get(){ return isDisposed; } 
    51                         private:        void set(bool value){ isDisposed = value;} 
    52                 } 
    5349                /// <summary> 
    5450                /// 出力するビデオファイルの名前を取得する 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/IplConvKernel.cpp

    r30899 r30907  
    2222                CHECK_NULL(ptr); 
    2323                this->Ptr = ptr; 
    24                 this->IsDisposed = false; 
    2524        } 
    2625        /// <summary> 
     
    3635                pin_ptr<int> values_ptr = (values != nullptr) ? &values[0] : nullptr; 
    3736                this->Ptr = ::cvCreateStructuringElementEx(cols, rows, anchor_x, anchor_y, static_cast<int>(shape), values_ptr); 
    38                 this->IsDisposed = false; 
    3937        } 
    4038        /// <summary> 
     
    4846        { 
    4947                this->Ptr = ::cvCreateStructuringElementEx(cols, rows, anchor_x, anchor_y, static_cast<int>(shape)); 
    50                 this->IsDisposed = false; 
    5148        } 
    5249        /// <summary> 
     
    7875        } 
    7976 
    80         /// <summary> 
    81         /// �t�@�C�i���C�U 
    82         /// </summary> 
    83         IplConvKernel::!IplConvKernel(void) 
    84         { 
    85                 if(!isDisposed){ 
    86                         Release(); 
    87                         isDisposed = true; 
    88                 } 
    89         } 
    90         /// <summary> 
    91         /// ���\�[�X�̉� 
    92         /// </summary> 
    93         IplConvKernel::~IplConvKernel(void) 
    94         { 
    95                 if(!isDisposed){ 
    96                         Release(); 
    97                         isDisposed = true; 
    98                 } 
    99         } 
    100  
    10177}} 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/IplConvKernel.h

    r30662 r30907  
    2222        /// 膨張・収縮処理で用いる構造要素 
    2323        /// </summary> 
    24         public ref class IplConvKernel : public IDisposable, public ICvObject 
     24        public ref class IplConvKernel : public DisposableObject, public ICvObject 
    2525        {        
    2626        private: 
    2727                bool isDisposed; 
    2828 
     29        protected: 
     30                virtual void Release( void ) override; 
     31 
    2932        internal: 
    3033                property struct _IplConvKernel* Ptr; 
    3134                IplConvKernel(__IplConvKernel* ptr);     
    32                 void Release(void); 
    33                  
    3435 
    3536        public: 
     
    3738                IplConvKernel(Int32 cols, Int32 rows, Int32 anchor_x, Int32 anchor_y, Shape shape); 
    3839                static N::IplConvKernel^ FromPtr( IntPtr ptr ); 
    39                 !IplConvKernel(void); 
    40                 ~IplConvKernel(void); 
    4140 
    4241                property Int32 NCols{ Int32 get(){ return Ptr->nCols; } } 
     
    5958                        Int32 get(void){ return sizeof(*Ptr); } 
    6059                } 
    61                 /// <summary> 
    62                 /// リソースが解放済みかどうか 
    63                 /// </summary> 
    64                 property bool IsDisposed{ 
    65                         public:         bool get(){ return isDisposed; } 
    66                         protected:      void set(bool value){ isDisposed = value;} 
    67                 } 
    6860 
    6961        }; 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/IplImage.h

    r26101 r30907  
    3939        private: 
    4040 
     41        protected: 
     42                virtual void Release( void ) override; 
     43 
    4144        internal: 
    4245                /// <summary> 
     
    4851                IplImage(__IplImage* ptr); 
    4952                IplImage(__IplImage* ptr, Boolean isEnabledDispose); 
    50                 virtual void Release( void ) override;   
    5153 
    5254        public:          
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/OpenCvSharp.vcproj

    r30899 r30907  
    650650                        </File> 
    651651                        <File 
     652                                RelativePath=".\DisposableObject.h" 
     653                                > 
     654                        </File> 
     655                        <File 
    652656                                RelativePath=".\Extras.h" 
    653657                                > 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/Stdafx.h

    r30778 r30907  
    2020#include <highgui.h> 
    2121#include <windows.h> 
     22#include "DisposableObject.h" 
    2223#include "ICvObject.h" 
    2324#include "StringConverter.h"