Changeset 23006

Show
Ignore:
Timestamp:
11/08/08 17:10:10 (5 years ago)
Author:
schima
Message:

線形代数関係のメソッドを実装

Location:
lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp
Files:
2 added
8 modified

Legend:

Unmodified
Added
Removed
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/AllEnums.h

    r22982 r23006  
    2828#include "InpaintMethod.h" 
    2929#include "Interpolation.h" 
     30#include "InvertMethod.h" 
    3031#include "LineType.h" 
    3132#include "LKFlowFlag.h" 
     
    4041#include "SmoothType.h" 
    4142#include "Subdiv2DPointLocation.h" 
     43#include "SvdFlag.h" 
    4244#include "TemplateMatching.h" 
    4345#include "ThresholdType.h" 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CV.cpp

    r22982 r23006  
    9292        } 
    9393        #pragma endregion 
    94         #pragma region _PREV_SEQ_ELEM 
     94        #pragma region PREV_SEQ_ELEM 
    9595        /// <summary> 
    9696        /// 前のシーケンスへ 
     
    107107        } 
    108108        #pragma endregion 
    109         #pragma region _READ_SEQ_ELEM 
     109        #pragma region READ_SEQ_ELEM 
    110110        /// <summary> 
    111111        /// シーケンスの要素を一つ読みだして、読み出しポインタを次へ1つ移動させる 
     
    113113        /// <param name="elem"></param> 
    114114        /// <param name="reader"></param> 
    115         generic <typename T>     
    116         void CV::READ_SEQ_ELEM( [Out] T% elem, N::CvSeqReader^ reader ) 
     115        generic <typename TYPE>          
     116        void CV::READ_SEQ_ELEM( [Out] TYPE% elem, N::CvSeqReader^ reader ) 
    117117        { 
    118118                CHECK_NULL(reader); 
    119                 int elem_size = Marshal::SizeOf(T::typeid); 
     119                int elem_size = Marshal::SizeOf(TYPE::typeid); 
    120120                IntPtr elem_ptr = Marshal::AllocHGlobal(elem_size); 
    121121                ::CvSeqReader* reader_ptr = reader->Ptr; 
     
    127127                NEXT_SEQ_ELEM( elem_size, reader );   
    128128 
    129                 elem = Cast<T>(elem_ptr.ToPointer()); 
     129                elem = Cast<TYPE>(elem_ptr.ToPointer()); 
    130130                Marshal::FreeHGlobal(elem_ptr); 
    131131        } 
     
    137137        /// <param name="elem"></param> 
    138138        /// <param name="reader"></param> 
    139         generic <typename T>     
    140         void CV::REV_READ_SEQ_ELEM( [Out] T% elem, N::CvSeqReader^ reader ) 
     139        generic <typename TYPE>          
     140        void CV::REV_READ_SEQ_ELEM( [Out] TYPE% elem, N::CvSeqReader^ reader ) 
    141141        { 
    142142                CHECK_NULL(reader); 
    143                 int elem_size = Marshal::SizeOf(T::typeid); 
     143                int elem_size = Marshal::SizeOf(TYPE::typeid); 
    144144                IntPtr elem_ptr = Marshal::AllocHGlobal(elem_size); 
    145145                ::CvSeqReader* reader_ptr = reader->Ptr; 
     
    151151                PREV_SEQ_ELEM( elem_size, reader );   
    152152 
    153                 elem = Cast<T>(elem_ptr.ToPointer()); 
     153                elem = Cast<TYPE>(elem_ptr.ToPointer()); 
    154154                Marshal::FreeHGlobal(elem_ptr); 
    155155        } 
     
    186186        /// <param name="a"></param> 
    187187        /// <param name="b"></param> 
    188         generic <typename T>             
    189         void CV::SWAP([In][Out] T% a, [In][Out] T% b) 
    190         { 
    191                 T temp = a; 
     188        generic <typename TYPE>          
     189        void CV::SWAP([In][Out] TYPE% a, [In][Out] TYPE% b) 
     190        { 
     191                TYPE temp = a; 
    192192                a = b; 
    193193                b = temp; 
     
    22542254        } 
    22552255        #pragma endregion  
     2256        #pragma region Det  
     2257        /// <summary> 
     2258        /// 行列式を返す 
     2259        /// </summary> 
     2260        /// <param name="mat">入力行列</param> 
     2261        /// <returns>行列式</returns> 
     2262        Double CV::Det( N::CvArr^ mat ) 
     2263        { 
     2264                CHECK_NULL(mat); 
     2265                return ::cvDet(mat->Ptr); 
     2266        } 
     2267        #pragma endregion  
    22562268        #pragma region DFT  
    22572269        /// <summary> 
     
    36723684        /// <param name="index">要素のインデックス. 負のインデックスの指定も可能で, 例えば,-1はシーケンスの最後の要素,-2は最後の一つ前を指す.</param> 
    36733685        /// <returns>与えられたインデックスを持つ要素.要素が見つからない場合はnull.</returns> 
    3674         generic<typename T> where T : ValueType, value class, gcnew() 
    3675         Nullable<T> CV::GetSeqElem( N::CvSeq^ seq, Int32 index ) 
     3686        generic<typename TYPE> where TYPE : ValueType, value class, gcnew() 
     3687        Nullable<TYPE> CV::GetSeqElem( N::CvSeq^ seq, Int32 index ) 
    36763688        { 
    36773689                CHECK_NULL(seq); 
    36783690                void* result = ::cvGetSeqElem(seq->SeqPtr, index); 
    3679                 Nullable<T> n; 
     3691                Nullable<TYPE> n; 
    36803692                if(result != NULL){ 
    3681                         n = Cast<T>(result); 
     3693                        n = Cast<TYPE>(result); 
    36823694                } 
    36833695                return n; 
     
    49104922        } 
    49114923        #pragma endregion 
     4924        #pragma region Invert 
     4925        /// <summary> 
     4926        /// 逆行列または擬似逆行列を求める. Invertのエイリアス. 
     4927        /// </summary> 
     4928        /// <param name="src">入力行列</param> 
     4929        /// <param name="dst">出力行列</param> 
     4930        /// <returns></returns> 
     4931        Double CV::Inv( N::CvArr^ src, N::CvArr^ dst ) 
     4932        { 
     4933                CHECK_NULL(src); 
     4934                CHECK_NULL(dst); 
     4935                return ::cvInv(src->Ptr, dst->Ptr); 
     4936        } 
     4937        /// <summary> 
     4938        /// 逆行列または擬似逆行列を求める. Invertのエイリアス. 
     4939        /// </summary> 
     4940        /// <param name="src">入力行列</param> 
     4941        /// <param name="dst">出力行列</param> 
     4942        /// <param name="method">逆行列を求める手法</param> 
     4943        /// <returns></returns> 
     4944        Double CV::Inv( N::CvArr^ src, N::CvArr^ dst, InvertMethod method ) 
     4945        { 
     4946                CHECK_NULL(src); 
     4947                CHECK_NULL(dst); 
     4948                return ::cvInv(src->Ptr, dst->Ptr, (int)method); 
     4949        } 
     4950        /// <summary> 
     4951        /// 逆行列または擬似逆行列を求める. 
     4952        /// </summary> 
     4953        /// <param name="src">入力行列</param> 
     4954        /// <param name="dst">出力行列</param> 
     4955        /// <returns></returns> 
     4956        Double CV::Invert( N::CvArr^ src, N::CvArr^ dst ) 
     4957        { 
     4958                CHECK_NULL(src); 
     4959                CHECK_NULL(dst); 
     4960                return ::cvInvert(src->Ptr, dst->Ptr); 
     4961        } 
     4962        /// <summary> 
     4963        /// 逆行列または擬似逆行列を求める. 
     4964        /// </summary> 
     4965        /// <param name="src">入力行列</param> 
     4966        /// <param name="dst">出力行列</param> 
     4967        /// <param name="method">逆行列を求める手法</param> 
     4968        /// <returns></returns> 
     4969        Double CV::Invert( N::CvArr^ src, N::CvArr^ dst, InvertMethod method ) 
     4970        { 
     4971                CHECK_NULL(src); 
     4972                CHECK_NULL(dst); 
     4973                return ::cvInvert(src->Ptr, dst->Ptr, (int)method); 
     4974        } 
     4975        #pragma endregion 
    49124976        #pragma region InvSqrt 
    49134977        /// <summary> 
     
    51215185        /// オブジェクトをファイルから読み込む 
    51225186        /// </summary> 
    5123         /// <typeparam name="T">読み込むオブジェクトの型</typeparam> 
     5187        /// <typeparam name="TYPE">読み込むオブジェクトの型</typeparam> 
    51245188        /// <param name="filename">ファイル名</param> 
    51255189        /// <returns>読み込んだオブジェクト</returns> 
    5126         generic<typename T> where T : N::ICvObject 
    5127         T CV::Load( String^ filename ) 
     5190        generic<typename TYPE> where TYPE : N::ICvObject 
     5191        TYPE CV::Load( String^ filename ) 
    51285192        { 
    51295193                CHECK_NULL(filename); 
    51305194                StringConverter^ conv_filename = gcnew StringConverter(filename); 
    51315195                void* result = ::cvLoad(conv_filename->ToCharPtr()); 
    5132                 return Cast<T>(result); 
     5196                return Cast<TYPE>(result); 
    51335197        } 
    51345198        /// <summary> 
    51355199        /// オブジェクトをファイルから読み込む 
    51365200        /// </summary> 
    5137         /// <typeparam name="T">読み込むオブジェクトの型</typeparam> 
     5201        /// <typeparam name="TYPE">読み込むオブジェクトの型</typeparam> 
    51385202        /// <param name="filename">ファイル名</param> 
    51395203        /// <param name="memstorage">CvSeqやCvGraph  などの動的構造体のためのメモリストレージ.行列や画像には用いられない.</param> 
    51405204        /// <returns>読み込んだオブジェクト</returns> 
    5141         generic<typename T> where T : N::ICvObject 
    5142         T CV::Load( String^ filename, N::CvMemStorage^ memstorage ) 
     5205        generic<typename TYPE> where TYPE : N::ICvObject 
     5206        TYPE CV::Load( String^ filename, N::CvMemStorage^ memstorage ) 
    51435207        { 
    51445208                CHECK_NULL(filename); 
     
    51465210                ::CvMemStorage* memstorage_ptr = (memstorage == nullptr) ? NULL : memstorage->Ptr; 
    51475211                void* result = ::cvLoad(conv_filename->ToCharPtr(), memstorage_ptr); 
    5148                 return Cast<T>(result); 
     5212                return Cast<TYPE>(result); 
    51495213        } 
    51505214        /// <summary> 
    51515215        /// オブジェクトをファイルから読み込む 
    51525216        /// </summary> 
    5153         /// <typeparam name="T">読み込むオブジェクトの型</typeparam> 
     5217        /// <typeparam name="TYPE">読み込むオブジェクトの型</typeparam> 
    51545218        /// <param name="filename">ファイル名</param> 
    51555219        /// <param name="memstorage">CvSeqやCvGraph  などの動的構造体のためのメモリストレージ.行列や画像には用いられない.</param> 
    51565220        /// <param name="name">オブジェクト名(オプション).nullの場合,ファイルストレージにある最初のトップレベルオブジェクトが読み込まれる. </param> 
    51575221        /// <returns>読み込んだオブジェクト</returns> 
    5158         generic<typename T> where T : N::ICvObject 
    5159         T CV::Load( String^ filename, N::CvMemStorage^ memstorage, String^ name ) 
     5222        generic<typename TYPE> where TYPE : N::ICvObject 
     5223        TYPE CV::Load( String^ filename, N::CvMemStorage^ memstorage, String^ name ) 
    51605224        { 
    51615225                CHECK_NULL(filename); 
     
    51645228                StringConverter^ conv_name = gcnew StringConverter(name); 
    51655229                void* result = ::cvLoad(conv_filename->ToCharPtr(), memstorage_ptr, conv_name->ToCharPtr()); 
    5166                 return Cast<T>(result); 
     5230                return Cast<TYPE>(result); 
    51675231        }        
    51685232        /// <summary> 
    51695233        /// オブジェクトをファイルから読み込む 
    51705234        /// </summary> 
    5171         /// <typeparam name="T">読み込むオブジェクトの型</typeparam> 
     5235        /// <typeparam name="TYPE">読み込むオブジェクトの型</typeparam> 
    51725236        /// <param name="filename">ファイル名</param> 
    51735237        /// <param name="memstorage">CvSeqやCvGraph  などの動的構造体のためのメモリストレージ.行列や画像には用いられない.</param> 
     
    51755239        /// <param name="real_name">読み込まれたオブジェクトの名前が代入される出力パラメータ(オプション)name=nullの場合に役立つ. </param> 
    51765240        /// <returns>読み込んだオブジェクト</returns> 
    5177         generic<typename T> where T : N::ICvObject 
    5178         T CV::Load( String^ filename, N::CvMemStorage^ memstorage, String^ name, array<String^>^ real_name ) 
     5241        generic<typename TYPE> where TYPE : N::ICvObject 
     5242        TYPE CV::Load( String^ filename, N::CvMemStorage^ memstorage, String^ name, array<String^>^ real_name ) 
    51795243        { 
    51805244                CHECK_NULL(filename); 
     
    51915255                } 
    51925256                void* result = ::cvLoad(conv_filename->ToCharPtr(), memstorage_ptr, conv_name->ToCharPtr(), (const char**)real_name_ptr); 
    5193                 return Cast<T>(result); 
     5257                return Cast<TYPE>(result); 
    51945258        } 
    51955259        #pragma endregion 
     
    57945858        } 
    57955859        #pragma endregion 
     5860        #pragma region MulTransposed 
     5861        /// <summary> 
     5862        /// 行列と転置行列の乗算を行う 
     5863        /// </summary> 
     5864        /// <param name="src">入力行列</param> 
     5865        /// <param name="dst">出力行列</param> 
     5866        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param> 
     5867        void CV::MulTransposed( N::CvArr^ src, N::CvArr^ dst, Boolean order ) 
     5868        { 
     5869                CHECK_NULL(src); 
     5870                CHECK_NULL(src); 
     5871                ::cvMulTransposed(src->Ptr, dst->Ptr, order?1:0); 
     5872        } 
     5873        /// <summary> 
     5874        /// 行列と転置行列の乗算を行う 
     5875        /// </summary> 
     5876        /// <param name="src">入力行列</param> 
     5877        /// <param name="dst">出力行列</param> 
     5878        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param> 
     5879        /// <param name="delta">オプション配列,乗算する前にsrcから引かれる.</param> 
     5880        void CV::MulTransposed( N::CvArr^ src, N::CvArr^ dst, Boolean order, N::CvArr^ delta ) 
     5881        { 
     5882                CHECK_NULL(src); 
     5883                CHECK_NULL(src); 
     5884                ::CvArr* delta_ptr = (delta == nullptr) ? NULL : delta->Ptr; 
     5885                ::cvMulTransposed(src->Ptr, dst->Ptr, order?1:0, delta_ptr); 
     5886        } 
     5887        /// <summary> 
     5888        /// 行列と転置行列の乗算を行う 
     5889        /// </summary> 
     5890        /// <param name="src">入力行列</param> 
     5891        /// <param name="dst">出力行列</param> 
     5892        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param> 
     5893        /// <param name="delta">オプション配列,乗算する前にsrcから引かれる.</param> 
     5894        /// <param name="scale"></param> 
     5895        void CV::MulTransposed( N::CvArr^ src, N::CvArr^ dst, Boolean order, N::CvArr^ delta, Double scale ) 
     5896        { 
     5897                CHECK_NULL(src); 
     5898                CHECK_NULL(src); 
     5899                ::CvArr* delta_ptr = (delta == nullptr) ? NULL : delta->Ptr; 
     5900                ::cvMulTransposed(src->Ptr, dst->Ptr, order?1:0, delta_ptr, scale); 
     5901        } 
     5902        #pragma endregion  
    57965903        #pragma region NamedWindow 
    57975904        /// <summary> 
     
    59816088                void* mask_ptr = (mask != nullptr) ? mask->Ptr : NULL; 
    59826089                ::cvOrS(src1->Ptr, value, dst->Ptr, mask_ptr); 
     6090        } 
     6091        #pragma endregion 
     6092        #pragma region PerspectiveTransform 
     6093        /// <summary> 
     6094        /// ベクトルの透視投影変換を行う 
     6095        /// </summary> 
     6096        /// <param name="src">3チャンネルの浮動小数点型入力配列</param> 
     6097        /// <param name="dst">3チャンネルの浮動小数点型出力配列</param> 
     6098        /// <param name="mat">3×3 または 4×4 の変換行列</param> 
     6099        void CV::PerspectiveTransform( N::CvArr^ src, N::CvArr^ dst, N::CvMat^ mat ) 
     6100        { 
     6101                CHECK_NULL(src); 
     6102                CHECK_NULL(dst); 
     6103                CHECK_NULL(mat); 
     6104                ::cvPerspectiveTransform(src->Ptr, dst->Ptr, mat->MatPtr); 
    59836105        } 
    59846106        #pragma endregion 
     
    61166238        } 
    61176239        #pragma endregion 
    6118         #pragma region PreCornerDetect 
     6240        #pragma region ProjectPoints2 
    61196241        /// <summary> 
    61206242        /// 次元空間中の点を画像平面上に投影した際の座標を,内部パラメータと外部パラメータを用いて計算する. 
     
    65646686        /// オブジェクトをデコードし,その参照を返す. 
    65656687        /// </summary> 
    6566         /// <typeparam name="T">返却値の型(CvArr派生型)</typeparam> 
     6688        /// <typeparam name="TYPE">返却値の型(CvArr派生型)</typeparam> 
    65676689        /// <param name="fs">ファイルストレージ</param> 
    65686690        /// <param name="node">ルートオブジェクトノード</param> 
    65696691        /// <returns></returns> 
    6570         generic<typename T> where T : N::CvArr 
    6571         T CV::Read( N::CvFileStorage^ fs, N::CvFileNode^ node ) 
     6692        generic<typename TYPE> where TYPE : N::CvArr 
     6693        TYPE CV::Read( N::CvFileStorage^ fs, N::CvFileNode^ node ) 
    65726694        { 
    65736695                CHECK_NULL(fs); 
    65746696                ::CvFileNode* node_ptr = (node == nullptr) ? NULL : node->Ptr; 
    65756697                ::CvArr* result = ::cvRead(fs->Ptr, node_ptr); 
    6576                 Type^ t = T::typeid; 
     6698                Type^ t = TYPE::typeid; 
    65776699                if(t == N::IplImage::typeid){ 
    6578                         return (T)gcnew N::IplImage((::IplImage*)result); 
     6700                        return (TYPE)gcnew N::IplImage((::IplImage*)result); 
    65796701                }else if(t == N::CvMat::typeid){ 
    6580                         return (T)gcnew N::CvMat((::CvMat*)result); 
     6702                        return (TYPE)gcnew N::CvMat((::CvMat*)result); 
    65816703                }else if(t == N::CvMatND::typeid){ 
    6582                         return (T)gcnew N::CvMatND((::CvMatND*)result); 
     6704                        return (TYPE)gcnew N::CvMatND((::CvMatND*)result); 
    65836705                }else if(t == N::CvSparseMat::typeid){ 
    6584                         return (T)gcnew N::CvSparseMat((::CvSparseMat*)result); 
     6706                        return (TYPE)gcnew N::CvSparseMat((::CvSparseMat*)result); 
    65856707                }else if(t == N::CvSeq::typeid){ 
    6586                         return (T)gcnew N::CvSeq((::CvSeq*)result); 
     6708                        return (TYPE)gcnew N::CvSeq((::CvSeq*)result); 
    65876709                }else{ 
    65886710                        throw gcnew InvalidCastException(); 
     
    65956717        /// cvGetFileNodeByName とcvReadの単純な合成である. 
    65966718        /// </summary> 
    6597         /// <typeparam name="T">返却値の型(CvArr派生型)</typeparam> 
     6719        /// <typeparam name="TYPE">返却値の型(CvArr派生型)</typeparam> 
    65986720        /// <param name="fs">ファイルストレージ</param> 
    65996721        /// <param name="map">親マップ.nullの場合,この関数はトップレベルノードを探索する.</param> 
    66006722        /// <param name="name">ノード名</param> 
    66016723        /// <returns></returns> 
    6602         generic<typename T> where T : N::CvArr 
    6603         T CV::ReadByName( N::CvFileStorage^ fs, N::CvFileNode^ map, String^ name ) 
     6724        generic<typename TYPE> where TYPE : N::CvArr 
     6725        TYPE CV::ReadByName( N::CvFileStorage^ fs, N::CvFileNode^ map, String^ name ) 
    66046726        { 
    66056727                CHECK_NULL(fs); 
     
    66076729                StringConverter^ conv = gcnew StringConverter(name); 
    66086730                ::CvArr* result = ::cvReadByName(fs->Ptr, map->Ptr, conv->ToCharPtr()); 
    6609                 Type^ t = T::typeid; 
     6731                Type^ t = TYPE::typeid; 
    66106732                if(t == N::IplImage::typeid){ 
    6611                         return (T)gcnew N::IplImage((::IplImage*)result); 
     6733                        return (TYPE)gcnew N::IplImage((::IplImage*)result); 
    66126734                }else if(t == N::CvMat::typeid){ 
    6613                         return (T)gcnew N::CvMat((::CvMat*)result); 
     6735                        return (TYPE)gcnew N::CvMat((::CvMat*)result); 
    66146736                }else if(t == N::CvMatND::typeid){ 
    6615                         return (T)gcnew N::CvMatND((::CvMatND*)result); 
     6737                        return (TYPE)gcnew N::CvMatND((::CvMatND*)result); 
    66166738                }else if(t == N::CvSparseMat::typeid){ 
    6617                         return (T)gcnew N::CvSparseMat((::CvSparseMat*)result); 
     6739                        return (TYPE)gcnew N::CvSparseMat((::CvSparseMat*)result); 
    66186740                }else if(t == N::CvSeq::typeid){ 
    6619                         return (T)gcnew N::CvSeq((::CvSeq*)result); 
     6741                        return (TYPE)gcnew N::CvSeq((::CvSeq*)result); 
    66206742                }else{ 
    66216743                        throw gcnew InvalidCastException(); 
     
    71297251        /// これは多次元配列を扱うことが可能(普通の画像と行列に対しても使用することが可能)で,さらに次元の変更も可能である. 
    71307252        /// </summary> 
    7131         /// <typeparam name="T">出力ヘッダの型</typeparam> 
     7253        /// <typeparam name="TYPE">出力ヘッダの型</typeparam> 
    71327254        /// <param name="arr">入力配列</param> 
    71337255        /// <param name="sizeof_header">IplImageとCvMat,CvMatNDそれぞれの出力ヘッダを区別するための出力ヘッダのサイズ.</param> 
     
    71377259        /// <param name="new_sizes">新しい次元サイズの配列.要素の総数は変化してはいけないので,new_dims-1の値のみ使用される.従って,new_dims = 1であればnew_sizesは使用されない.</param> 
    71387260        /// <returns></returns> 
    7139         generic <typename T> where T : N::CvArr 
    7140                 T CV::ReshapeMatND( N::CvArr^ arr, Int32 sizeof_header, T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
     7261        generic <typename TYPE> where TYPE : N::CvArr 
     7262                TYPE CV::ReshapeMatND( N::CvArr^ arr, Int32 sizeof_header, TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
    71417263        { 
    71427264                CHECK_NULL(arr); 
     
    71477269                ::CvArr* result = ::cvReshapeMatND(arr->Ptr, sizeof_header, header->Ptr, new_cn, new_dims, new_sizes_ptr); 
    71487270                 
    7149                 Type^ t = T::typeid; 
     7271                Type^ t = TYPE::typeid; 
    71507272                if(t == N::IplImage::typeid){ 
    7151                         return (T)gcnew N::IplImage((__IplImage*)result, false); 
     7273                        return (TYPE)gcnew N::IplImage((__IplImage*)result, false); 
    71527274                }else if(t == N::CvMat::typeid){ 
    7153                         return (T)gcnew N::CvMat((__CvMat*)result, false); 
     7275                        return (TYPE)gcnew N::CvMat((__CvMat*)result, false); 
    71547276                }else if(t == N::CvMatND::typeid){ 
    7155                         return (T)gcnew N::CvMatND((__CvMatND*)result, false); 
     7277                        return (TYPE)gcnew N::CvMatND((__CvMatND*)result, false); 
    71567278                }else{ 
    71577279                        throw gcnew InvalidCastException(); 
     
    71627284        /// これは多次元配列を扱うことが可能(普通の画像と行列に対しても使用することが可能)で,さらに次元の変更も可能である. 
    71637285        /// </summary> 
    7164         /// <typeparam name="T">出力ヘッダの型</typeparam> 
     7286        /// <typeparam name="TYPE">出力ヘッダの型</typeparam> 
    71657287        /// <param name="arr">入力配列</param> 
    71667288        /// <param name="header">書き込まれる出力ヘッダ</param> 
     
    71697291        /// <param name="new_sizes">新しい次元サイズの配列.要素の総数は変化してはいけないので,new_dims-1の値のみ使用される.従って,new_dims = 1であればnew_sizesは使用されない.</param> 
    71707292        /// <returns></returns> 
    7171         generic <typename T> where T : N::CvArr 
    7172                 T CV::ReshapeND( N::CvArr^ arr, T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
     7293        generic <typename TYPE> where TYPE : N::CvArr 
     7294                TYPE CV::ReshapeND( N::CvArr^ arr, TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
    71737295        { 
    71747296                CHECK_NULL(arr); 
     
    73917513        /// 挿入された要素への参照を返す. 
    73927514        /// </summary> 
    7393         /// <typeparam name="T">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
     7515        /// <typeparam name="TYPE">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
    73947516        /// <param name="seq">シーケンス</param> 
    73957517        /// <param name="before_index">要素が挿入されるインデックス(このインデックスの前に挿入される)</param> 
    73967518        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param> 
    73977519        /// <returns>追加された要素</returns> 
    7398         generic<typename T>  
    7399         T CV::SeqInsert( N::CvSeq^ seq, Int32 before_index, T element ) 
     7520        generic<typename TYPE>  
     7521        TYPE CV::SeqInsert( N::CvSeq^ seq, Int32 before_index, TYPE element ) 
    74007522        { 
    74017523                CHECK_NULL(seq); 
    74027524                void* result = cvSeqInsert_(seq->CvPtr, before_index, element).ToPointer();              
    7403                 return Cast<T>(result); 
     7525                return Cast<TYPE>(result); 
    74047526        } 
    74057527        #pragma endregion  
     
    74337555        /// シーケンスが既に空の場合は,エラーを返す.この関数の計算量は O(1) である. 
    74347556        /// </summary> 
    7435         /// <typeparam name="T">出力先オブジェクトの型</typeparam> 
     7557        /// <typeparam name="TYPE">出力先オブジェクトの型</typeparam> 
    74367558        /// <param name="seq">シーケンス</param> 
    74377559        /// <param name="element">削除した要素をコピーする出力先</param> 
    7438         generic<typename T> 
    7439         void CV::SeqPop( N::CvSeq^ seq, [Out] T% element ) 
     7560        generic<typename TYPE> 
     7561        void CV::SeqPop( N::CvSeq^ seq, [Out] TYPE% element ) 
    74407562        { 
    74417563                CHECK_NULL(seq); 
    74427564                // elementのメモリ領域を確保 
    7443                 IntPtr ptr = Marshal::AllocHGlobal(Marshal::SizeOf(T::typeid)); 
     7565                IntPtr ptr = Marshal::AllocHGlobal(Marshal::SizeOf(TYPE::typeid)); 
    74447566                // ptrにpopした結果を格納してもらう 
    74457567                ::cvSeqPop(seq->SeqPtr, ptr.ToPointer()); 
    74467568                // T型にキャスト 
    7447                 element = Cast<T>(ptr.ToPointer()); 
     7569                element = Cast<TYPE>(ptr.ToPointer()); 
    74487570                // 後始末 
    74497571                Marshal::FreeHGlobal(ptr); 
     
    74657587        /// シーケンスが既に空の場合は,エラーを返す.この関数の計算量は O(1) である. 
    74667588        /// </summary> 
    7467         /// <typeparam name="T">出力先オブジェクトの型</typeparam> 
     7589        /// <typeparam name="TYPE">出力先オブジェクトの型</typeparam> 
    74687590        /// <param name="seq">シーケンス</param> 
    74697591        /// <param name="element">削除した要素をコピーする出力先</param> 
    7470         generic<typename T> 
    7471         void CV::SeqPopFront( N::CvSeq^ seq, [Out] T% element ) 
     7592        generic<typename TYPE> 
     7593        void CV::SeqPopFront( N::CvSeq^ seq, [Out] TYPE% element ) 
    74727594        { 
    74737595                CHECK_NULL(seq); 
    74747596                // elementのメモリ領域を確保 
    7475                 IntPtr ptr = Marshal::AllocHGlobal(Marshal::SizeOf(T::typeid)); 
     7597                IntPtr ptr = Marshal::AllocHGlobal(Marshal::SizeOf(TYPE::typeid)); 
    74767598                // ptrにpopした結果を格納してもらう 
    74777599                ::cvSeqPopFront(seq->SeqPtr, ptr.ToPointer()); 
    74787600                // T型にキャスト 
    7479                 element = Cast<T>(ptr.ToPointer()); 
     7601                element = Cast<TYPE>(ptr.ToPointer()); 
    74807602                // 後始末 
    74817603                Marshal::FreeHGlobal(ptr); 
     
    74967618        /// 入力の element が null の場合,この関数は単に要素一つ分の領域を確保する. 
    74977619        /// </summary> 
    7498         /// <typeparam name="T">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
     7620        /// <typeparam name="TYPE">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
    74997621        /// <param name="seq">シーケンス</param> 
    75007622        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param> 
    75017623        /// <returns>追加された要素</returns> 
    7502         generic<typename T>  
    7503         T CV::SeqPush( N::CvSeq^ seq, T element ) 
     7624        generic<typename TYPE>  
     7625        TYPE CV::SeqPush( N::CvSeq^ seq, TYPE element ) 
    75047626        { 
    75057627                CHECK_NULL(seq); 
    75067628                void* result = cvSeqPush_(seq->CvPtr, element).ToPointer();              
    7507                 return Cast<T>(result); 
     7629                return Cast<TYPE>(result); 
    75087630        } 
    75097631        #pragma endregion  
     
    75227644        /// 入力の element が null の場合,この関数は単に要素一つ分の領域を確保する. 
    75237645        /// </summary> 
    7524         /// <typeparam name="T">追加する要素の型. プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
     7646        /// <typeparam name="TYPE">追加する要素の型. プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
    75257647        /// <param name="seq">シーケンス</param> 
    75267648        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param> 
    75277649        /// <returns>追加された要素</returns> 
    7528         generic<typename T>  
    7529         T CV::SeqPushFront( N::CvSeq^ seq, T element ) 
     7650        generic<typename TYPE>  
     7651        TYPE CV::SeqPushFront( N::CvSeq^ seq, TYPE element ) 
    75307652        { 
    75317653                CHECK_NULL(seq); 
    75327654                void* result = cvSeqPushFront_(seq->CvPtr, element).ToPointer();                 
    7533                 return Cast<T>(result); 
     7655                return Cast<TYPE>(result); 
    75347656        } 
    75357657        #pragma endregion  
     
    75417663        /// 線形探索を用いて要素を見つけた場合,インデックスにはseq(i)>elemである最小のインデックスiがセットされる.  
    75427664        /// </summary> 
     7665        /// <typeparam name="TYPE">検索する要素の型. プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
    75437666        /// <param name="seq">ソートされるシーケンス</param> 
    75447667        /// <param name="elem">検索する要素</param> 
     
    75467669        /// <param name="is_sorted">シーケンスがソート済みか否かを示すフラグ</param> 
    75477670        /// <param name="elem_idx">出力パラメータ.見つかった要素のインデックス.</param> 
    7548         generic<typename T>  where T : ValueType, value class, gcnew() 
    7549         Nullable<T> CV::SeqSearch( N::CvSeq^ seq, T elem, CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ) 
     7671        generic<typename TYPE>  where TYPE : ValueType, value class, gcnew() 
     7672        Nullable<TYPE> CV::SeqSearch( N::CvSeq^ seq, TYPE elem, CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ) 
    75507673        { 
    75517674                CHECK_NULL(seq); 
    75527675                CHECK_NULL(func); 
    75537676                IntPtr result = cvSeqSearch_(IntPtr(seq->SeqPtr), elem, func, is_sorted, elem_idx); 
    7554                 Nullable<T> n; 
     7677                Nullable<TYPE> n; 
    75557678                if(result != IntPtr::Zero){ 
    7556                         n = Cast<T>(result.ToPointer()); 
     7679                        n = Cast<TYPE>(result.ToPointer()); 
    75577680                } 
    75587681                return n; 
     
    84218544        }        
    84228545        #pragma endregion  
     8546        #pragma region Solve 
     8547        /// <summary> 
     8548        /// 線形問題または最小二乗法問題を解く. dst = arg min_x||A*X-B|| 
     8549        /// </summary> 
     8550        /// <param name="src1">入力行列</param> 
     8551        /// <param name="src2">線形システムの右辺</param> 
     8552        /// <param name="dst">出力解</param> 
     8553        /// <returns>methodにLUを指定した場合,Aが正則行列であればtrueを返し,そうでなければfalseを返す.</returns> 
     8554        Boolean CV::Solve( N::CvArr^ src1, N::CvArr^ src2, N::CvArr^ dst ) 
     8555        { 
     8556                CHECK_NULL(src1); 
     8557                CHECK_NULL(src2); 
     8558                CHECK_NULL(dst); 
     8559                return ::cvSolve(src1->Ptr, src2->Ptr, dst->Ptr) != 0; 
     8560        } 
     8561        /// <summary> 
     8562        /// 線形問題または最小二乗法問題を解く. dst = arg min_x||A*X-B|| 
     8563        /// </summary> 
     8564        /// <param name="src1">入力行列</param> 
     8565        /// <param name="src2">線形システムの右辺</param> 
     8566        /// <param name="dst">出力解</param> 
     8567        /// <param name="method">逆行列の解法</param> 
     8568        /// <returns>methodにLUを指定した場合,Aが正則行列であればtrueを返し,そうでなければfalseを返す.</returns> 
     8569        Boolean CV::Solve( N::CvArr^ src1, N::CvArr^ src2, N::CvArr^ dst, InvertMethod method ) 
     8570        { 
     8571                CHECK_NULL(src1); 
     8572                CHECK_NULL(src2); 
     8573                CHECK_NULL(dst); 
     8574                return ::cvSolve(src1->Ptr, src2->Ptr, dst->Ptr, (int)method) != 0; 
     8575        } 
     8576        #pragma endregion 
    84238577        #pragma region Split 
    84248578        /// <summary> 
     
    87588912        } 
    87598913        #pragma endregion 
     8914        #pragma region SVD 
     8915        /// <summary> 
     8916        /// 浮動小数点型の実数行列の特異値分解を行う. 
     8917        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     8918        /// </summary> 
     8919        /// <param name="A">入力M×N行列</param> 
     8920        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     8921        void CV::SVD( N::CvArr^ A, N::CvArr^ W ) 
     8922        { 
     8923                CHECK_NULL(A); 
     8924                CHECK_NULL(W); 
     8925                ::cvSVD(A->Ptr, W->Ptr); 
     8926        } 
     8927        /// <summary> 
     8928        /// 浮動小数点型の実数行列の特異値分解を行う. 
     8929        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     8930        /// </summary> 
     8931        /// <param name="A">入力M×N行列</param> 
     8932        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     8933        /// <param name="U">任意の左直交行列 (M×M または M×N).もしCV_SVD_U_Tが指定された場合,上で述べた,行と列の数は入れ替わる.</param> 
     8934        void CV::SVD( N::CvArr^ A, N::CvArr^ W, N::CvArr^ U ) 
     8935        { 
     8936                CHECK_NULL(A); 
     8937                CHECK_NULL(W); 
     8938                ::CvArr* U_ptr = (U == nullptr) ? NULL : U->Ptr; 
     8939                ::cvSVD(A->Ptr, W->Ptr, U_ptr); 
     8940        } 
     8941        /// <summary> 
     8942        /// 浮動小数点型の実数行列の特異値分解を行う. 
     8943        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     8944        /// </summary> 
     8945        /// <param name="A">入力M×N行列</param> 
     8946        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     8947        /// <param name="U">任意の左直交行列 (M×M または M×N).もしCV_SVD_U_Tが指定された場合,上で述べた,行と列の数は入れ替わる.</param> 
     8948        /// <param name="V">任意の右直交行列(N×N).</param> 
     8949        void CV::SVD( N::CvArr^ A, N::CvArr^ W, N::CvArr^ U, N::CvArr^ V ) 
     8950        { 
     8951                CHECK_NULL(A); 
     8952                CHECK_NULL(W); 
     8953                ::CvArr* U_ptr = (U == nullptr) ? NULL : U->Ptr; 
     8954                ::CvArr* V_ptr = (V == nullptr) ? NULL : V->Ptr; 
     8955                ::cvSVD(A->Ptr, W->Ptr, U_ptr, V_ptr); 
     8956        } 
     8957        /// <summary> 
     8958        /// 浮動小数点型の実数行列の特異値分解を行う. 
     8959        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     8960        /// </summary> 
     8961        /// <param name="A">入力M×N行列</param> 
     8962        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     8963        /// <param name="U">任意の左直交行列 (M×M または M×N).もしCV_SVD_U_Tが指定された場合,上で述べた,行と列の数は入れ替わる.</param> 
     8964        /// <param name="V">任意の右直交行列(N×N).</param> 
     8965        /// <param name="flags">操作フラグ</param> 
     8966        void CV::SVD( N::CvArr^ A, N::CvArr^ W, N::CvArr^ U, N::CvArr^ V, SvdFlag flags ) 
     8967        { 
     8968                CHECK_NULL(A); 
     8969                CHECK_NULL(W); 
     8970                ::CvArr* U_ptr = (U == nullptr) ? NULL : U->Ptr; 
     8971                ::CvArr* V_ptr = (V == nullptr) ? NULL : V->Ptr; 
     8972                ::cvSVD(A->Ptr, W->Ptr, U_ptr, V_ptr, (int)flags); 
     8973        } 
     8974        #pragma endregion 
    87608975        #pragma region ThreshHist 
    87618976        /// <summary> 
     
    88169031        } 
    88179032        #pragma endregion  
     9033        #pragma region Transpose 
     9034        /// <summary> 
     9035        /// 行列の転置を行う. 
     9036        /// </summary> 
     9037        /// <param name="src">入力行列</param> 
     9038        /// <param name="dst">出力行列</param> 
     9039        void CV::Transpose( N::CvArr^ src, N::CvArr^ dst ) 
     9040        { 
     9041                CHECK_NULL(src); 
     9042                CHECK_NULL(dst); 
     9043                ::cvTranspose(src->Ptr, dst->Ptr); 
     9044        } 
     9045        /// <summary> 
     9046        /// 行列の転置を行う. Transposeのエイリアス. 
     9047        /// </summary> 
     9048        /// <param name="src">入力行列</param> 
     9049        /// <param name="dst">出力行列</param> 
     9050        void CV::T( N::CvArr^ src, N::CvArr^ dst ) 
     9051        { 
     9052                CHECK_NULL(src); 
     9053                CHECK_NULL(dst); 
     9054                ::cvTranspose(src->Ptr, dst->Ptr); 
     9055        } 
     9056        #pragma endregion  
     9057        #pragma region Trace 
     9058        /// <summary> 
     9059        /// 行列のトレース(対角成分の和)を返す 
     9060        /// </summary> 
     9061        /// <param name="mat">入力行列</param> 
     9062        /// <returns>対角成分の和</returns> 
     9063        N::CvScalar CV::Trace( N::CvArr^ mat ) 
     9064        { 
     9065                CHECK_NULL(mat); 
     9066                return ::cvTrace(mat->Ptr); 
     9067        } 
     9068        #pragma endregion  
    88189069        #pragma region Undistort2 
    88199070        /// <summary> 
     
    91639414        /// TがOpenCVのオブジェクトの場合は、T型のstaticメソッド"FromPtr"による変換を試みる. 
    91649415        /// </summary> 
    9165         /// <typeparam name="T">追加する要素の型. プリミティブ型か、OpenCVのオブジェクト.</typeparam> 
     9416        /// <typeparam name="TYPE">オブジェクトの型. プリミティブ型か、OpenCVのオブジェクト(ICvObject).</typeparam> 
    91669417        /// <param name="p">変換するポインタ</param> 
    91679418        /// <returns>T型に変換した結果</returns> 
    9168         generic <typename T> 
    9169         T CV::Cast(void* p) 
    9170         { 
    9171                 Type^ t = T::typeid; 
     9419        generic <typename TYPE> 
     9420        TYPE CV::Cast(void* p) 
     9421        { 
     9422                Type^ t = TYPE::typeid; 
    91729423                // ポインタで返す場合 
    91739424                if(t == IntPtr::typeid){ 
    9174                         return (T)IntPtr(p); 
     9425                        return (TYPE)IntPtr(p); 
    91759426                } 
    91769427                // プリミティブ型は普通に変換を試みる 
    91779428                else if(t == Boolean::typeid){ 
    9178                         return (T)*((Boolean*)p); 
     9429                        return (TYPE)*((Boolean*)p); 
    91799430                }else if(t == Byte::typeid){ 
    9180                         return (T)*((Byte*)p); 
     9431                        return (TYPE)*((Byte*)p); 
    91819432                }else if(t == SByte::typeid){ 
    9182                         return (T)*((SByte*)p); 
     9433                        return (TYPE)*((SByte*)p); 
    91839434                }else if(t == Int16::typeid){ 
    9184                         return (T)*((Int16*)p); 
     9435                        return (TYPE)*((Int16*)p); 
    91859436                }else if(t == Char::typeid){ 
    9186                         return (T)*((Char*)p); 
     9437                        return (TYPE)*((Char*)p); 
    91879438                }else if(t == UInt16::typeid){ 
    9188                         return (T)*((UInt16*)p); 
     9439                        return (TYPE)*((UInt16*)p); 
    91899440                }else if(t == Int32::typeid){ 
    9190                         return (T)*((Int32*)p); 
     9441                        return (TYPE)*((Int32*)p); 
    91919442                }else if(t == UInt32::typeid){ 
    9192                         return (T)*((UInt32*)p); 
     9443                        return (TYPE)*((UInt32*)p); 
    91939444                }else if(t == Int64::typeid){ 
    9194                         return (T)*((Int64*)p); 
     9445                        return (TYPE)*((Int64*)p); 
    91959446                }else if(t == UInt64::typeid){ 
    9196                         return (T)*((UInt64*)p); 
     9447                        return (TYPE)*((UInt64*)p); 
    91979448                }else if(t == Single::typeid){ 
    9198                         return (T)*((Single*)p); 
     9449                        return (TYPE)*((Single*)p); 
    91999450                }else if(t == Double::typeid){ 
    9200                         return (T)*((Double*)p); 
     9451                        return (TYPE)*((Double*)p); 
    92019452                }else if(t == Decimal::typeid){ 
    9202                         return (T)*((Decimal*)p); 
     9453                        return (TYPE)*((Decimal*)p); 
    92039454                }else{ 
    92049455                        // その他の場合は、OpenCVのオブジェクトであることを期待してポインタからのオブジェクト生成を試みる. 
     
    92079458                        MethodInfo^ info = t->GetMethod("FromPtr", BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Static); 
    92089459                        if (info != nullptr) { 
    9209                                 return (T)info->Invoke(nullptr, gcnew array<Object^>{IntPtr(p)}); 
     9460                                return (TYPE)info->Invoke(nullptr, gcnew array<Object^>{IntPtr(p)}); 
    92109461                        }else{ 
    92119462                                throw gcnew InvalidCastException("予期しない型です"); 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CV.h

    r22982 r23006  
    4444                static void NEXT_SEQ_ELEM( Int32 elem_size, N::CvSeqReader^ reader ); 
    4545                static void PREV_SEQ_ELEM( Int32 elem_size, N::CvSeqReader^ reader ); 
    46                 generic <typename T>             
    47                         static void READ_SEQ_ELEM( [Out] T% elem, N::CvSeqReader^ reader ); 
    48                 generic <typename T>             
    49                         static void REV_READ_SEQ_ELEM( [Out] T% elem, N::CvSeqReader^ reader ); 
     46                generic <typename TYPE>                  
     47                        static void READ_SEQ_ELEM( [Out] TYPE% elem, N::CvSeqReader^ reader ); 
     48                generic <typename TYPE>                  
     49                        static void REV_READ_SEQ_ELEM( [Out] TYPE% elem, N::CvSeqReader^ reader ); 
    5050                static void SWAP([In][Out] Object^% a, [In][Out] Object^% b, [In][Out] Object^% t); 
    51                 generic <typename T>  
    52                         static void SWAP([In][Out] T% a, [In][Out] T% b); 
     51                generic <typename TYPE> 
     52                        static void SWAP([In][Out] TYPE% a, [In][Out] TYPE% b); 
    5353 
    5454                static N::CvMat^ _2DRotationMatrix( N::CvPoint2D32f center, Double angle, Double scale ); 
     
    184184                static void     DestroyAllWindows( void ); 
    185185                static void     DestroyWindow( String^ name ); 
     186                static Double Det( N::CvArr^ mat ); 
    186187                static void DFT( N::CvArr^ src, N::CvArr^ dst, DftFlag flags ); 
    187188                static void DFT( N::CvArr^ src, N::CvArr^ dst, DftFlag flags, Int32 nonzero_rows ); 
     
    269270                static N::CvMat^ GetRows( N::CvArr^ arr, [Out] N::CvMat^% submat, Int32 start_row, Int32 end_row ); 
    270271                static N::CvMat^ GetRows( N::CvArr^ arr, [Out] N::CvMat^% submat, Int32 start_row, Int32 end_row, Int32 delta_row ); 
    271                 generic<typename T> where T : ValueType, value class, gcnew() 
    272                         static Nullable<T> GetSeqElem( N::CvSeq^ seq, Int32 index ); 
     272                generic<typename TYPE> where TYPE : ValueType, value class, gcnew() 
     273                        static Nullable<TYPE> GetSeqElem( N::CvSeq^ seq, Int32 index ); 
    273274                static Int32 GetSeqReaderPos( N::CvSeqReader^ reader ); 
    274275                static N::CvSize GetSize( N::CvArr^ arr ); 
     
    340341                static void InRange( N::CvArr^ src, N::CvArr^ lower, N::CvArr^ upper, N::CvArr^ dst ); 
    341342                static void InRangeS( N::CvArr^ src, N::CvScalar lower, N::CvScalar upper, N::CvArr^ dst ); 
     343                static Double Inv( N::CvArr^ src, N::CvArr^ dst ); 
     344                static Double Inv( N::CvArr^ src, N::CvArr^ dst, InvertMethod method ); 
     345                static Double Invert( N::CvArr^ src, N::CvArr^ dst ); 
     346                static Double Invert( N::CvArr^ src, N::CvArr^ dst, InvertMethod method ); 
    342347                static Single InvSqrt( Single value ); 
    343348                static Boolean IsInf( Double value ); 
     
    356361                static void     Line( N::CvArr^ img, N::CvPoint pt1, N::CvPoint pt2, N::CvColor color, Int32 thickness, LineType line_type); 
    357362                static void     Line( N::CvArr^ img, N::CvPoint pt1, N::CvPoint pt2, N::CvColor color, Int32 thickness, LineType line_type, Int32 shift);                
    358                 generic<typename T> where T : N::ICvObject 
    359                 static T Load( String^ filename ); 
    360                 generic<typename T> where T : N::ICvObject 
    361                 static T Load( String^ filename, N::CvMemStorage^ memstorage ); 
    362                 generic<typename T> where T : N::ICvObject 
    363                 static T Load( String^ filename, N::CvMemStorage^ memstorage, String^ name ); 
    364                 generic<typename T> where T : N::ICvObject 
    365                 static T Load( String^ filename, N::CvMemStorage^ memstorage, String^ name, array<String^>^ real_name ); 
     363                generic<typename TYPE> where TYPE : N::ICvObject 
     364                static TYPE Load( String^ filename ); 
     365                generic<typename TYPE> where TYPE : N::ICvObject 
     366                static TYPE Load( String^ filename, N::CvMemStorage^ memstorage ); 
     367                generic<typename TYPE> where TYPE : N::ICvObject 
     368                static TYPE Load( String^ filename, N::CvMemStorage^ memstorage, String^ name ); 
     369                generic<typename TYPE> where TYPE : N::ICvObject 
     370                static TYPE Load( String^ filename, N::CvMemStorage^ memstorage, String^ name, array<String^>^ real_name ); 
    366371                static N::IplImage^     LoadImage( String^ filename ); 
    367372                static N::IplImage^     LoadImage( String^ filename, LoadMode flags ); 
     
    400405                static void Mul( N::CvArr^ src1, N::CvArr^ src2, N::CvArr^ dst, Double scale ); 
    401406                static void MulAddS( N::CvArr^ src1, N::CvScalar scale, N::CvArr^ src2, N::CvArr^ dst ); 
     407                static void MulTransposed( N::CvArr^ src, N::CvArr^ dst, Boolean order ); 
     408                static void MulTransposed( N::CvArr^ src, N::CvArr^ dst, Boolean order, N::CvArr^ delta ); 
     409                static void MulTransposed( N::CvArr^ src, N::CvArr^ dst, Boolean order, N::CvArr^ delta, Double scale ); 
    402410                static Int32 NamedWindow( String^ name ); 
    403411                static Int32 NamedWindow( String^ name, WindowFlag flags );      
     
    413421                static void OrS( N::CvArr^ src1, N::CvScalar value, N::CvArr^ dst, N::CvArr^ mask ); 
    414422                static void OrS( N::CvArr^ src1, N::CvScalar value, N::CvArr^ dst ); 
     423                static void PerspectiveTransform( N::CvArr^ src, N::CvArr^ dst, N::CvMat^ mat ); 
    415424                static void PolyLine( N::CvArr^ img, array<array<N::CvPoint>^>^ pts, Boolean is_closed, N::CvColor color ); 
    416425                static void PolyLine( N::CvArr^ img, array<array<N::CvPoint>^>^ pts, Boolean is_closed, N::CvColor color, Int32 thickness ); 
     
    444453                static void RandShuffle( N::CvArr^ mat, N::CvRNG^ rng, Double iter_factor ); 
    445454                static void Range( N::CvArr^ mat, Double start, Double end ); 
    446                 generic<typename T> where T : N::CvArr 
    447                         static T Read( N::CvFileStorage^ fs, N::CvFileNode^ node ); 
    448                 generic<typename T> where T : N::CvArr 
    449                         static T ReadByName( N::CvFileStorage^ fs, N::CvFileNode^ map, String^ name ); 
     455                generic<typename TYPE> where TYPE : N::CvArr 
     456                        static TYPE Read( N::CvFileStorage^ fs, N::CvFileNode^ node ); 
     457                generic<typename TYPE> where TYPE : N::CvArr 
     458                        static TYPE ReadByName( N::CvFileStorage^ fs, N::CvFileNode^ map, String^ name ); 
    450459                static Int32 ReadInt( N::CvFileNode^ node ); 
    451460                static Int32 ReadInt( N::CvFileNode^ node, Int32 default_value ); 
     
    482491                static N::CvMat^ Reshape( N::CvArr^ arr, N::CvMat^ header, Int32 new_cn ); 
    483492                static N::CvMat^ Reshape( N::CvArr^ arr, N::CvMat^ header, Int32 new_cn, Int32 new_rows ); 
    484                 generic <typename T> where T : N::CvArr  
    485                         static T ReshapeMatND( N::CvArr^ arr, Int32 sizeof_header, T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
    486                 generic <typename T> where T : N::CvArr  
    487                         static T ReshapeND( N::CvArr^ arr, T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
     493                generic <typename TYPE> where TYPE : N::CvArr    
     494                        static TYPE ReshapeMatND( N::CvArr^ arr, Int32 sizeof_header, TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
     495                generic <typename TYPE> where TYPE : N::CvArr    
     496                        static TYPE ReshapeND( N::CvArr^ arr, TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
    488497                static void     Resize( N::CvArr^ src, N::CvArr^ dst ); 
    489498                static void     Resize( N::CvArr^ src, N::CvArr^ dst, N::Interpolation interpolation ); 
     
    500509                static void Scale( N::CvArr^ src, N::CvArr^ dst, Double scale, Double shift );   
    501510                static void ScaleAdd( N::CvArr^ src1, N::CvScalar scale, N::CvArr^ src2, N::CvArr^ dst ); 
    502                 generic<typename T>  
    503                         static T SeqInsert( N::CvSeq^ seq, Int32 before_index, T element ); 
     511                generic<typename TYPE>  
     512                        static TYPE SeqInsert( N::CvSeq^ seq, Int32 before_index, TYPE element ); 
    504513                static void SeqRemove( N::CvSeq^ seq, Int32 index ); 
    505514                static void SeqPop( N::CvSeq^ seq ); 
    506                 generic<typename T>  
    507                         static void SeqPop( N::CvSeq^ seq, [Out] T% element ); 
     515                generic<typename TYPE>  
     516                        static void SeqPop( N::CvSeq^ seq, [Out] TYPE% element ); 
    508517                static void SeqPopFront( N::CvSeq^ seq ); 
    509                 generic<typename T>  
    510                         static void SeqPopFront( N::CvSeq^ seq, [Out] T% element ); 
     518                generic<typename TYPE>  
     519                        static void SeqPopFront( N::CvSeq^ seq, [Out] TYPE% element ); 
    511520                static void SeqPush( N::CvSeq^ seq ); 
    512                 generic<typename T>  
    513                         static T SeqPush( N::CvSeq^ seq, T element ); 
     521                generic<typename TYPE>  
     522                        static TYPE SeqPush( N::CvSeq^ seq, TYPE element ); 
    514523                static void SeqPushFront( N::CvSeq^ seq ); 
    515                 generic<typename T>  
    516                         static T SeqPushFront( N::CvSeq^ seq, T element ); 
    517                 generic<typename T> where T : ValueType, value class, gcnew() 
    518                         static Nullable<T> SeqSearch( N::CvSeq^ seq, T elem, N::CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ); 
     524                generic<typename TYPE>  
     525                        static TYPE SeqPushFront( N::CvSeq^ seq, TYPE element ); 
     526                generic<typename TYPE> where TYPE : ValueType, value class, gcnew() 
     527                        static Nullable<TYPE> SeqSearch( N::CvSeq^ seq, TYPE elem, N::CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ); 
    519528                static void SeqSort( N::CvSeq^ seq, N::CvComparison^ func ); 
    520529                static void Set( N::CvArr^ arr, N::CvScalar value ); 
     
    568577                static void Sobel( N::CvArr^ src, N::CvArr^ dst, Int32 xorder, Int32 yorder ); 
    569578                static void Sobel( N::CvArr^ src, N::CvArr^ dst, Int32 xorder, Int32 yorder, ApertureSize aperture_size ); 
     579                static Boolean Solve( N::CvArr^ src1, N::CvArr^ src2, N::CvArr^ dst ); 
     580                static Boolean Solve( N::CvArr^ src1, N::CvArr^ src2, N::CvArr^ dst, InvertMethod method ); 
    570581                static void Split( N::CvArr^ src, N::CvArr^ dst0, N::CvArr^ dst1, N::CvArr^ dst2, N::CvArr^ dst3 ); 
    571582                static Single Sqrt( Single value ); 
     
    589600                static void SubRS( N::CvArr^ src, N::CvScalar value, N::CvArr^ dst ); 
    590601                static N::CvScalar Sum( N::CvArr^ arr ); 
     602                static void SVD( N::CvArr^ A, N::CvArr^ W ); 
     603                static void SVD( N::CvArr^ A, N::CvArr^ W, N::CvArr^ U ); 
     604                static void SVD( N::CvArr^ A, N::CvArr^ W, N::CvArr^ U, N::CvArr^ V ); 
     605                static void SVD( N::CvArr^ A, N::CvArr^ W, N::CvArr^ U, N::CvArr^ V, SvdFlag flags ); 
     606                static void T( N::CvArr^ src, N::CvArr^ dst ); 
    591607                static void ThreshHist( N::CvHistogram^ hist, Double threshold ); 
    592608                static void Threshold( N::CvArr^ src, N::CvArr^ dst, Double threshold, Double max_value, ThresholdType threshold_type ); 
    593609                static void Transform( N::CvArr^ src, N::CvArr^ dst, N::CvMat^ transmat ); 
    594610                static void Transform( N::CvArr^ src, N::CvArr^ dst, N::CvMat^ transmat, N::CvMat^ shiftvec ); 
     611                static void Transpose( N::CvArr^ src, N::CvArr^ dst ); 
     612                static N::CvScalar Trace( N::CvArr^ mat ); 
    595613                static void Undistort2( N::CvArr^ src, N::CvArr^ dst, N::CvMat^ intrinsic_matrix, N::CvMat^ distortion_coeffs ); 
    596614                static Int32 WaitKey( void ); 
     
    630648 
    631649 
    632                 generic <typename T> 
    633                 static T Cast(void* p); 
     650                generic <typename TYPE> 
     651                static TYPE Cast(void* p); 
    634652        }; 
    635653 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvArr.cpp

    r22982 r23006  
    506506        } 
    507507        #pragma endregion  
     508        #pragma region Det  
     509        /// <summary> 
     510        /// 行列式を返す (cvDet相当) 
     511        /// </summary> 
     512        /// <returns>行列式</returns> 
     513        Double CvArr::Det( void ) 
     514        { 
     515                return CV::Det(this); 
     516        } 
     517        #pragma endregion  
    508518        #pragma region DistTransform 
    509519        /// <summary> 
     
    12111221        } 
    12121222        #pragma endregion 
     1223        #pragma region Invert 
     1224        /// <summary> 
     1225        /// 逆行列または擬似逆行列を求める. Invertのエイリアス. 
     1226        /// </summary> 
     1227        /// <param name="dst">出力行列</param> 
     1228        /// <returns></returns> 
     1229        Double CvArr::Inv( N::CvArr^ dst ) 
     1230        { 
     1231                return CV::Inv(this, dst); 
     1232        } 
     1233        /// <summary> 
     1234        /// 逆行列または擬似逆行列を求める. Invertのエイリアス. 
     1235        /// </summary> 
     1236        /// <param name="dst">出力行列</param> 
     1237        /// <param name="method">逆行列を求める手法</param> 
     1238        /// <returns></returns> 
     1239        Double CvArr::Inv( N::CvArr^ dst, InvertMethod method ) 
     1240        { 
     1241                return CV::Inv(this, dst, method); 
     1242        } 
     1243        /// <summary> 
     1244        /// 逆行列または擬似逆行列を求める (cvInvert相当). 
     1245        /// </summary> 
     1246        /// <param name="dst">出力行列</param> 
     1247        /// <returns></returns> 
     1248        Double CvArr::Invert( N::CvArr^ dst ) 
     1249        { 
     1250                return CV::Invert(this, dst); 
     1251        } 
     1252        /// <summary> 
     1253        /// 逆行列または擬似逆行列を求める (cvInvert相当). 
     1254        /// </summary> 
     1255        /// <param name="dst">出力行列</param> 
     1256        /// <param name="method">逆行列を求める手法</param> 
     1257        /// <returns></returns> 
     1258        Double CvArr::Invert( N::CvArr^ dst, InvertMethod method ) 
     1259        { 
     1260                return CV::Invert(this, dst, method); 
     1261        } 
     1262        #pragma endregion 
    12131263        #pragma region Laplace 
    12141264        /// <summary> 
     
    14101460        } 
    14111461        #pragma endregion  
     1462        #pragma region MulTransposed 
     1463        /// <summary> 
     1464        /// 行列と転置行列の乗算を行う (cvMulTransposed相当) 
     1465        /// </summary> 
     1466        /// <param name="dst">出力行列</param> 
     1467        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param> 
     1468        void CvArr::MulTransposed( N::CvArr^ dst, Boolean order ) 
     1469        { 
     1470                CV::MulTransposed(this, dst, order); 
     1471        } 
     1472        /// <summary> 
     1473        /// 行列と転置行列の乗算を行う (cvMulTransposed相当) 
     1474        /// </summary> 
     1475        /// <param name="dst">出力行列</param> 
     1476        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param> 
     1477        /// <param name="delta">オプション配列,乗算する前にsrcから引かれる.</param> 
     1478        void CvArr::MulTransposed( N::CvArr^ dst, Boolean order, N::CvArr^ delta ) 
     1479        { 
     1480                CV::MulTransposed(this, dst, order, delta); 
     1481        } 
     1482        /// <summary> 
     1483        /// 行列と転置行列の乗算を行う (cvMulTransposed相当) 
     1484        /// </summary> 
     1485        /// <param name="dst">出力行列</param> 
     1486        /// <param name="order">転置した行列をかける順番を示すフラグ. falseの場合, dst=(src-delta)*(src-delta)^T, trueの場合, dst=(src-delta)^T*(src-delta)</param> 
     1487        /// <param name="delta">オプション配列,乗算する前にsrcから引かれる.</param> 
     1488        /// <param name="scale"></param> 
     1489        void CvArr::MulTransposed( N::CvArr^ dst, Boolean order, N::CvArr^ delta, Double scale ) 
     1490        { 
     1491                CV::MulTransposed(this, dst, order, delta, scale); 
     1492        } 
     1493        #pragma endregion  
    14121494        #pragma region Normalize 
    14131495        /// <summary> 
     
    14531535        } 
    14541536        #pragma endregion  
     1537        #pragma region PerspectiveTransform 
     1538        /// <summary> 
     1539        /// ベクトルの透視投影変換を行う (cvPerspectiveTransform相当) 
     1540        /// </summary> 
     1541        /// <param name="dst">3チャンネルの浮動小数点型出力配列</param> 
     1542        /// <param name="mat">3×3 または 4×4 の変換行列</param> 
     1543        void CvArr::PerspectiveTransform( N::CvArr^ dst, N::CvMat^ mat ) 
     1544        { 
     1545                CV::PerspectiveTransform(this, dst, mat); 
     1546        } 
     1547        #pragma endregion 
    14551548        #pragma region PolyLine 
    14561549        /// <summary> 
     
    17221815        /// これは多次元配列を扱うことが可能(普通の画像と行列に対しても使用することが可能)で,さらに次元の変更も可能である. 
    17231816        /// </summary> 
    1724         /// <typeparam name="T">出力ヘッダの型</typeparam> 
     1817        /// <typeparam name="TYPE">出力ヘッダの型</typeparam> 
    17251818        /// <param name="sizeof_header">IplImageとCvMat,CvMatNDそれぞれの出力ヘッダを区別するための出力ヘッダのサイズ.</param> 
    17261819        /// <param name="header">書き込まれる出力ヘッダ</param> 
     
    17291822        /// <param name="new_sizes">新しい次元サイズの配列.要素の総数は変化してはいけないので,new_dims-1の値のみ使用される.従って,new_dims = 1であればnew_sizesは使用されない.</param> 
    17301823        /// <returns></returns> 
    1731         generic <typename T> where T : N::CvArr 
    1732                 T CvArr::ReshapeMatND( Int32 sizeof_header, T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
     1824        generic <typename TYPE> where TYPE : N::CvArr 
     1825                TYPE CvArr::ReshapeMatND( Int32 sizeof_header, TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
    17331826        { 
    17341827                return CV::ReshapeMatND(this, sizeof_header, header, new_cn, new_dims, new_sizes); 
     
    17381831        /// これは多次元配列を扱うことが可能(普通の画像と行列に対しても使用することが可能)で,さらに次元の変更も可能である. 
    17391832        /// </summary> 
    1740         /// <typeparam name="T">出力ヘッダの型</typeparam> 
     1833        /// <typeparam name="TYPE">出力ヘッダの型</typeparam> 
    17411834        /// <param name="header">書き込まれる出力ヘッダ</param> 
    17421835        /// <param name="new_cn">新しいチャンネル数 .new_cn = 0はチャンネル数が変更されていないことを意味する.</param> 
     
    17441837        /// <param name="new_sizes">新しい次元サイズの配列.要素の総数は変化してはいけないので,new_dims-1の値のみ使用される.従って,new_dims = 1であればnew_sizesは使用されない.</param> 
    17451838        /// <returns></returns> 
    1746         generic <typename T> where T : N::CvArr 
    1747                 T CvArr::ReshapeND( T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
     1839        generic <typename TYPE> where TYPE : N::CvArr 
     1840                TYPE CvArr::ReshapeND( TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ) 
    17481841        { 
    17491842                return CV::ReshapeND(this, header, new_cn, new_dims, new_sizes); 
     
    21612254        } 
    21622255        #pragma endregion 
     2256        #pragma region Solve 
     2257        /// <summary> 
     2258        /// 線形問題または最小二乗法問題を解く (cvSolve相当). dst = arg min_x||A*X-B|| 
     2259        /// </summary> 
     2260        /// <param name="src2">線形システムの右辺</param> 
     2261        /// <param name="dst">出力解</param> 
     2262        /// <returns>methodにLUを指定した場合,Aが正則行列であればtrueを返し,そうでなければfalseを返す.</returns> 
     2263        Boolean CvArr::Solve( N::CvArr^ src2, N::CvArr^ dst ) 
     2264        { 
     2265                return CV::Solve(this, src2, dst); 
     2266        } 
     2267        /// <summary> 
     2268        /// 線形問題または最小二乗法問題を解く (cvSolve相当). dst = arg min_x||A*X-B|| 
     2269        /// </summary> 
     2270        /// <param name="src2">線形システムの右辺</param> 
     2271        /// <param name="dst">出力解</param> 
     2272        /// <param name="method">逆行列の解法</param> 
     2273        /// <returns>methodにLUを指定した場合,Aが正則行列であればtrueを返し,そうでなければfalseを返す.</returns> 
     2274        Boolean CvArr::Solve( N::CvArr^ src2, N::CvArr^ dst, InvertMethod method ) 
     2275        { 
     2276                return CV::Solve(this, src2, dst, method); 
     2277        } 
     2278        #pragma endregion 
    21632279        #pragma region Split 
    21642280        /// <summary> 
     
    22222338        } 
    22232339        #pragma endregion 
     2340        #pragma region SVD 
     2341        /// <summary> 
     2342        /// 浮動小数点型の実数行列の特異値分解を行う (cvSVD相当). 
     2343        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     2344        /// </summary> 
     2345        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     2346        void CvArr::SVD( N::CvArr^ W ) 
     2347        { 
     2348                CV::SVD(this, W); 
     2349        } 
     2350        /// <summary> 
     2351        /// 浮動小数点型の実数行列の特異値分解を行う (cvSVD相当). 
     2352        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     2353        /// </summary> 
     2354        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     2355        /// <param name="U">任意の左直交行列 (M×M または M×N).もしCV_SVD_U_Tが指定された場合,上で述べた,行と列の数は入れ替わる.</param> 
     2356        void CvArr::SVD( N::CvArr^ W, N::CvArr^ U ) 
     2357        { 
     2358                CV::SVD(this, W, U); 
     2359        } 
     2360        /// <summary> 
     2361        /// 浮動小数点型の実数行列の特異値分解を行う (cvSVD相当). 
     2362        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     2363        /// </summary> 
     2364        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     2365        /// <param name="U">任意の左直交行列 (M×M または M×N).もしCV_SVD_U_Tが指定された場合,上で述べた,行と列の数は入れ替わる.</param> 
     2366        /// <param name="V">任意の右直交行列(N×N).</param> 
     2367        void CvArr::SVD( N::CvArr^ W, N::CvArr^ U, N::CvArr^ V ) 
     2368        { 
     2369                CV::SVD(this, W, U, V); 
     2370        } 
     2371        /// <summary> 
     2372        /// 浮動小数点型の実数行列の特異値分解を行う (cvSVD相当). 
     2373        /// 行列Aを二つの直交行列と一つの対角行列の積に分解する.A=U*W*VT 
     2374        /// </summary> 
     2375        /// <param name="W">特異値行列の結果 (M×N または N×N)またはベクトル(N×1).</param> 
     2376        /// <param name="U">任意の左直交行列 (M×M または M×N).もしCV_SVD_U_Tが指定された場合,上で述べた,行と列の数は入れ替わる.</param> 
     2377        /// <param name="V">任意の右直交行列(N×N).</param> 
     2378        /// <param name="flags">操作フラグ</param> 
     2379        void CvArr::SVD( N::CvArr^ W, N::CvArr^ U, N::CvArr^ V, SvdFlag flags ) 
     2380        { 
     2381                CV::SVD(this, W, U, V, flags); 
     2382        } 
     2383        #pragma endregion 
    22242384        #pragma region Threshold 
    22252385        /// <summary> 
     
    22542414        { 
    22552415                CV::Transform(this, dst, transmat, shiftvec); 
     2416        } 
     2417        #pragma endregion  
     2418        #pragma region Transpose 
     2419        /// <summary> 
     2420        /// 行列の転置を行う (cvTranspose相当). 
     2421        /// </summary> 
     2422        /// <param name="dst">出力行列</param> 
     2423        void CvArr::Transpose( N::CvArr^ dst ) 
     2424        { 
     2425                CV::Transpose(this, dst); 
     2426        } 
     2427        /// <summary> 
     2428        /// 行列の転置を行う. Transposeのエイリアス. 
     2429        /// </summary> 
     2430        /// <param name="dst">出力行列</param> 
     2431        void CvArr::T( N::CvArr^ dst ) 
     2432        { 
     2433                CV::T(this, dst); 
     2434        } 
     2435        #pragma endregion  
     2436        #pragma region Trace 
     2437        /// <summary> 
     2438        /// 行列のトレース(対角成分の和)を返す (cvTrace相当) 
     2439        /// </summary> 
     2440        /// <returns>対角成分の和</returns> 
     2441        N::CvScalar CvArr::Trace( void ) 
     2442        { 
     2443                return CV::Trace(this); 
    22562444        } 
    22572445        #pragma endregion  
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvArr.h

    r22982 r23006  
    244244                virtual void CrossProduct( N::CvArr^ src2, N::CvArr^ dst ); 
    245245                virtual void DecRefData( void ); 
     246                virtual Double Det( void ); 
    246247                virtual void DistTransform( N::CvArr^ dst ); 
    247248                virtual void DistTransform( N::CvArr^ dst, DistanceType distance_type ); 
     
    300301                virtual Int32 IncRefData( void ); 
    301302                virtual void Inpaint( N::CvArr^ mask, N::CvArr^ dst, Double inpaintRange, InpaintMethod flags ); 
     303                virtual Double Inv( N::CvArr^ dst ); 
     304                virtual Double Inv( N::CvArr^ dst, InvertMethod method ); 
     305                virtual Double Invert( N::CvArr^ dst ); 
     306                virtual Double Invert( N::CvArr^ dst, InvertMethod method ); 
    302307                virtual void Laplace( N::CvArr^ dst ); 
    303308                virtual void Laplace( N::CvArr^ dst, ApertureSize aperture_size ); 
     
    316321                virtual void MinMaxLoc( [Out] Double% min_val, [Out] Double% max_val, [Out] N::CvPoint% min_loc, [Out] N::CvPoint% max_loc, N::CvArr^ mask ); 
    317322                virtual void MulAddS( N::CvScalar scale, N::CvArr^ src2, N::CvArr^ dst ); 
     323                virtual void MulTransposed( N::CvArr^ dst, Boolean order ); 
     324                virtual void MulTransposed( N::CvArr^ dst, Boolean order, N::CvArr^ delta ); 
     325                virtual void MulTransposed( N::CvArr^ dst, Boolean order, N::CvArr^ delta, Double scale ); 
    318326                virtual void Normalize( N::CvArr^ dst ); 
    319327                virtual void Normalize( N::CvArr^ dst, Double a, Double b ); 
    320328                virtual void Normalize( N::CvArr^ dst, Double a, Double b, NormType norm_type ); 
    321329                virtual void Normalize( N::CvArr^ dst, Double a, Double b, NormType norm_type, N::CvArr^ mask ); 
     330                virtual void PerspectiveTransform( N::CvArr^ dst, N::CvMat^ mat ); 
    322331                virtual void PolyLine( array<array<N::CvPoint>^>^ pts, Boolean is_closed, N::CvColor color ); 
    323332                virtual void PolyLine( array<array<N::CvPoint>^>^ pts, Boolean is_closed, N::CvColor color, Int32 thickness ); 
     
    342351                virtual N::CvMat^ Reshape( N::CvMat^ header, Int32 new_cn ); 
    343352                virtual N::CvMat^ Reshape( N::CvMat^ header, Int32 new_cn, Int32 new_rows ); 
    344                 generic <typename T> where T : N::CvArr  
    345                         virtual T ReshapeMatND( Int32 sizeof_header, T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
    346                 generic <typename T> where T : N::CvArr  
    347                         virtual T ReshapeND( T header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
     353                generic <typename TYPE> where TYPE : N::CvArr    
     354                        virtual TYPE ReshapeMatND( Int32 sizeof_header, TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
     355                generic <typename TYPE> where TYPE : N::CvArr    
     356                        virtual TYPE ReshapeND( TYPE header, Int32 new_cn, Int32 new_dims, array<Int32>^ new_sizes ); 
    348357                virtual Int32 SaveImage( String^ filename ); 
    349358                virtual void Scale( N::CvArr^ dst ); 
     
    378387                virtual void Smooth( N::CvArr^ dst, SmoothType smoothtype, Int32 param1, Int32 param2, Double param3, Double param4 );   
    379388                virtual void Sobel( N::CvArr^ dst, Int32 xorder, Int32 yorder ); 
    380                 virtual void Sobel( N::CvArr^ dst, Int32 xorder, Int32 yorder, ApertureSize aperture_size );             
     389                virtual void Sobel( N::CvArr^ dst, Int32 xorder, Int32 yorder, ApertureSize aperture_size );     
     390                virtual Boolean Solve( N::CvArr^ src2, N::CvArr^ dst ); 
     391                virtual Boolean Solve( N::CvArr^ src2, N::CvArr^ dst, InvertMethod method ); 
    381392                virtual void Split( N::CvArr^ dst0, N::CvArr^ dst1, N::CvArr^ dst2, N::CvArr^ dst3 );    
    382393                virtual void Sub( N::CvArr^ src, N::CvArr^ dst, N::CvArr^ mask ); 
     
    384395                virtual void SubRS( N::CvScalar value, N::CvArr^ dst, N::CvArr^ mask );  
    385396                virtual N::CvScalar Sum( void ); 
     397                virtual void SVD( N::CvArr^ W ); 
     398                virtual void SVD( N::CvArr^ W, N::CvArr^ U ); 
     399                virtual void SVD( N::CvArr^ W, N::CvArr^ U, N::CvArr^ V ); 
     400                virtual void SVD( N::CvArr^ W, N::CvArr^ U, N::CvArr^ V, SvdFlag flags ); 
     401                virtual void T( N::CvArr^ dst ); 
    386402                virtual void Threshold( N::CvArr^ dst, Double threshold, Double max_value, N::ThresholdType threshold_type ); 
    387403                virtual void Transform( N::CvArr^ dst, N::CvMat^ transmat ); 
    388404                virtual void Transform( N::CvArr^ dst, N::CvMat^ transmat, N::CvMat^ shiftvec ); 
     405                virtual void Transpose( N::CvArr^ dst ); 
     406                virtual N::CvScalar Trace( void ); 
    389407                virtual void Undistort2( N::CvArr^ dst, N::CvMat^ intrinsic_matrix, N::CvMat^ distortion_coeffs ); 
    390408                virtual void Watershed( N::CvArr^ markers ); 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvSeq.cpp

    r22982 r23006  
    180180        /// ブロック数が要素数より非常に小さいと仮定した場合は,関数の時間計算量はO(1)になる. 
    181181        /// </summary> 
    182         /// <typeparam name="T">出力オブジェクトの型</typeparam> 
     182        /// <typeparam name="TYPE">出力オブジェクトの型</typeparam> 
    183183        /// <param name="index">要素のインデックス</param> 
    184         generic<typename T> where T : ValueType, value class, gcnew() 
    185         Nullable<T> CvSeq::GetElem( Int32 index ) 
    186         { 
    187                 return CV::GetSeqElem<T>(this, index); 
     184        generic<typename TYPE> where TYPE : ValueType, value class, gcnew() 
     185        Nullable<TYPE> CvSeq::GetElem( Int32 index ) 
     186        { 
     187                return CV::GetSeqElem<TYPE>(this, index); 
    188188        } 
    189189        #pragma endregion 
     
    197197        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param> 
    198198        /// <returns>追加された要素</returns> 
    199         generic<typename T>  
    200         T CvSeq::Insert( Int32 before_index, T element ) 
    201         { 
    202                 return CV::SeqInsert<T>(this, before_index, element); 
     199        generic<typename TYPE>  
     200        TYPE CvSeq::Insert( Int32 before_index, TYPE element ) 
     201        { 
     202                return CV::SeqInsert<TYPE>(this, before_index, element); 
    203203        } 
    204204        #pragma endregion  
     
    220220        /// シーケンスが既に空の場合は,エラーを返す.この関数の計算量は O(1) である. 
    221221        /// </summary> 
    222         /// <typeparam name="T">出力先オブジェクトの型</typeparam> 
     222        /// <typeparam name="TYPE">出力先オブジェクトの型</typeparam> 
    223223        /// <returns>削除された要素</returns> 
    224         generic<typename T> 
    225         T CvSeq::Pop( void ) 
    226         { 
    227                 T result; 
    228                 CV::SeqPop<T>(this, result); 
     224        generic<typename TYPE> 
     225        TYPE CvSeq::Pop( void ) 
     226        { 
     227                TYPE result; 
     228                CV::SeqPop<TYPE>(this, result); 
    229229                return result; 
    230230        } 
     
    235235        /// シーケンスが既に空の場合は,エラーを返す.この関数の計算量は O(1) である. 
    236236        /// </summary> 
    237         /// <typeparam name="T">出力先オブジェクトの型</typeparam> 
     237        /// <typeparam name="TYPE">出力先オブジェクトの型</typeparam> 
    238238        /// <returns>削除された要素</returns> 
    239         generic<typename T> 
    240         T CvSeq::PopFront( void ) 
    241         { 
    242                 T result; 
    243                 CV::SeqPopFront<T>(this, result); 
     239        generic<typename TYPE> 
     240        TYPE CvSeq::PopFront( void ) 
     241        { 
     242                TYPE result; 
     243                CV::SeqPopFront<TYPE>(this, result); 
    244244                return result; 
    245245        } 
     
    249249        /// シーケンスの末尾に要素を追加し,割り付けられた要素を返す (cvSeqPush相当). 
    250250        /// </summary> 
    251         /// <typeparam name="T">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
     251        /// <typeparam name="TYPE">追加する要素の型.プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
    252252        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param> 
    253253        /// <returns>追加された要素</returns> 
    254         generic<typename T>  
    255         T CvSeq::Push( T element ) 
    256         { 
    257                 return CV::SeqPush<T>(this, element); 
     254        generic<typename TYPE>  
     255        TYPE CvSeq::Push( TYPE element ) 
     256        { 
     257                return CV::SeqPush<TYPE>(this, element); 
    258258        } 
    259259        #pragma endregion  
     
    262262        /// シーケンスの先頭に要素を追加し,割り付けられた要素を返す (cvSeqPushFront相当). 
    263263        /// </summary> 
    264         /// <typeparam name="T">追加する要素の型. プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
     264        /// <typeparam name="TYPE">追加する要素の型. プリミティブ型か、OpenCVの構造体(CvPointなど).</typeparam> 
    265265        /// <param name="element">追加される要素. プリミティブ型か、OpenCVの構造体(CvPointなど).</param> 
    266266        /// <returns>追加された要素</returns> 
    267         generic<typename T>  
    268         T CvSeq::PushFront( T element ) 
    269         { 
    270                 return CV::SeqPushFront<T>(this, element); 
     267        generic<typename TYPE>  
     268        TYPE CvSeq::PushFront( TYPE element ) 
     269        { 
     270                return CV::SeqPushFront<TYPE>(this, element); 
    271271        } 
    272272        #pragma endregion  
     
    282282        /// <param name="is_sorted">シーケンスがソート済みか否かを示すフラグ</param> 
    283283        /// <param name="elem_idx">出力パラメータ.見つかった要素のインデックス.</param> 
    284         generic<typename T>  where T : ValueType, value class, gcnew() 
    285         Nullable<T> CvSeq::Search( T elem, CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ) 
     284        generic<typename TYPE>  where TYPE : ValueType, value class, gcnew() 
     285        Nullable<TYPE> CvSeq::Search( TYPE elem, CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ) 
    286286        { 
    287287                CHECK_NULL(func); 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/CvSeq.h

    r22982 r23006  
    149149                #pragma region CvSeq 独自メソッド 
    150150                void Clear( void ); 
    151                 generic<typename T> where T : ValueType, value class, gcnew()  Nullable<T> GetElem( Int32 index ); 
    152                 generic<typename T> T Insert( Int32 before_index, T element ); 
     151                generic<typename TYPE> where TYPE : ValueType, value class, gcnew()  Nullable<TYPE> GetElem( Int32 index ); 
     152                generic<typename TYPE> TYPE Insert( Int32 before_index, TYPE element ); 
    153153                void Remove( Int32 index ); 
    154                 generic<typename T> T Pop( void ); 
    155                 generic<typename T> T PopFront( void ); 
    156                 generic<typename T> T Push( T element ); 
    157                 generic<typename T> T PushFront( T element ); 
    158                 generic<typename T> where T : ValueType, value class, gcnew()  Nullable<T> Search( T elem, CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ); 
     154                generic<typename TYPE> TYPE Pop( void ); 
     155                generic<typename TYPE> TYPE PopFront( void ); 
     156                generic<typename TYPE> TYPE Push( TYPE element ); 
     157                generic<typename TYPE> TYPE PushFront( TYPE element ); 
     158                generic<typename TYPE> where TYPE : ValueType, value class, gcnew()  Nullable<TYPE> Search( TYPE elem, CvComparison^ func, Boolean is_sorted, [Out] Int32% elem_idx ); 
    159159                void SetBlockSize( Int32 delta_elems ); 
    160160                void Sort( CvComparison^ func ); 
  • lang/cpluspluscli/OpenCvSharp/trunk/OpenCvSharp/OpenCvSharp.vcproj

    r22982 r23006  
    629629                                </File> 
    630630                                <File 
     631                                        RelativePath=".\InvertMethod.h" 
     632                                        > 
     633                                </File> 
     634                                <File 
    631635                                        RelativePath=".\LineType.h" 
    632636                                        > 
     
    682686                                <File 
    683687                                        RelativePath=".\Subdiv2DPointLocation.h" 
     688                                        > 
     689                                </File> 
     690                                <File 
     691                                        RelativePath=".\SvdFlag.h" 
    684692                                        > 
    685693                                </File>