Context Navigation

← Previous Changeset
Next Changeset →

Changeset 31236

Timestamp:

03/15/09 12:34:00 (4 years ago)

Author:

schima

Message:

CvHistogramを実装

Location:

lang/cpluspluscli/OpenCvSharp2/trunk

Files:

: 6 added
: 11 modified

OpenCvSharp.Core/CvInline.h (modified) (1 diff)
OpenCvSharp.Core/OpenCvSharp.Core.vcproj (modified) (4 diffs)
OpenCvSharp.Core/WCvHistogram.h (modified) (1 diff)
OpenCvSharp.Core/WCvMatND.cpp (added)
OpenCvSharp.Core/WCvMatND.h (added)
OpenCvSharp.Core/WCvSparseMat.cpp (added)
OpenCvSharp.Core/WCvSparseMat.h (added)
OpenCvSharp.Test/Program.cs (modified) (2 diffs)
OpenCvSharp/ArrayAddress.cs (modified) (2 diffs)
OpenCvSharp/Class/CvHistogram.cs (modified) (8 diffs)
OpenCvSharp/Core/CvDll.cs (modified) (7 diffs)
OpenCvSharp/Core/Cv_Cv.cs (modified) (1 diff)
OpenCvSharp/Core/Cv_CxCore.cs (modified) (3 diffs)
OpenCvSharp/CvArr/CvArr.cs (modified) (1 diff)
OpenCvSharp/CvArr/CvMatND.cs (added)
OpenCvSharp/CvArr/CvSparseMat.cs (added)
OpenCvSharp/OpenCvSharp.csproj (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed

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

r31229	r31236
75	75	return ::cvIsInf(value);
76	76	}
	77	// cvGetHistValue_*D
	78	static IntPtr cvGetHistValue_1D_( IntPtr hist, int idx0 ){
	79	CvHistogram* _hist = (CvHistogram*)hist.ToPointer();
	80	float* result = cvGetHistValue_1D(_hist, idx0);
	81	return IntPtr(result);
	82	}
	83	static IntPtr cvGetHistValue_2D_( IntPtr hist, int idx0, int idx1 ) {
	84	CvHistogram* _hist = (CvHistogram*)hist.ToPointer();
	85	float* result = cvGetHistValue_2D(_hist, idx0, idx1);
	86	return IntPtr(result);
	87	}
	88	static IntPtr cvGetHistValue_3D_( IntPtr hist, int idx0, int idx1, int idx2 ) {
	89	CvHistogram* _hist = (CvHistogram*)hist.ToPointer();
	90	float* result = cvGetHistValue_3D(_hist, idx0, idx1, idx2);
	91	return IntPtr(result);
	92	}
	93	static IntPtr cvGetHistValue_nD_( IntPtr hist, array<int>^ idx ) {
	94	CvHistogram* _hist = (CvHistogram*)hist.ToPointer();
	95	pin_ptr<int> idx_ptr = &idx[0];
	96	float* result = cvGetHistValue_nD(_hist, idx_ptr);
	97	return IntPtr(result);
	98	}
77	99	// cvQueryHistValue_*D
78	100	static double cvQueryHistValue_1D_( IntPtr hist, int idx0 ) {

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Core/OpenCvSharp.Core.vcproj

r31229	r31236
244	244	</File>
245	245	<File
	246	RelativePath=".\WCvMatND.cpp"
	247	>
	248	</File>
	249	<File
246	250	RelativePath=".\WCvMemStorage.cpp"
247	251	>
…	…
269	273	<File
270	274	RelativePath=".\WCvSetElem.cpp"
	275	>
	276	</File>
	277	<File
	278	RelativePath=".\WCvSparseMat.cpp"
271	279	>
272	280	</File>
…	…
330	338	</File>
331	339	<File
	340	RelativePath=".\WCvMatND.h"
	341	>
	342	</File>
	343	<File
332	344	RelativePath=".\WCvMemStorage.h"
333	345	>
…	…
355	367	<File
356	368	RelativePath=".\WCvSetElem.h"
	369	>
	370	</File>
	371	<File
	372	RelativePath=".\WCvSparseMat.h"
357	373	>
358	374	</File>

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp.Core/WCvHistogram.h

r31229	r31236
61	61	}
62	62
	63
	64	/// <summary>
	65	///
	66	/// </summary>
	67	property int mat_type{
	68	int get(void) { return _ptr->mat.type; }
	69	}
	70	/// <summary>
	71	///
	72	/// </summary>
	73	property int mat_dims{
	74	int get(void) { return _ptr->mat.dims; }
	75	}
	76	/// <summary>
	77	///
	78	/// </summary>
	79	property IntPtr mat_data{
	80	IntPtr get(void) { return IntPtr(_ptr->mat.data.ptr); }
	81	}
	82
63	83	};
64	84	}

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

r31225	r31236
86	86	//Sample.CornerDetect();
87	87	// ドロネー
88		//new Test.Delaunay();
	88	new Test.Delaunay();
89	89	// 離散フーリエ変換
90		new Test.DFT();
	90	//new Test.DFT();
91	91	// 距離変換とその可視化
92	92	//Sample.DistTransform();
…	…
104	104	//new Test.FindContours();
105	105	// ヒストグラムの描画
106		~~//Sample~~.Histogram();
	106	new Test.Histogram();
107	107	// ハフ変換による直線検出
108	108	//Sample.HoughLines();

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/ArrayAddress.cs

r31229	r31236
84	84	// T[][]をIntPtr[]に変換する
85	85	this.ptr = new IntPtr[array.Length];
86		~~GCHandle[]~~ gch = new GCHandle[array.Length];
	86	this.gch = new GCHandle[array.Length];
87	87	for (int i = 0; i < array.Length; i++)
88	88	{
…	…
96	96	}
97	97	}
	98
98	99
99	100	/// <summary>

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Class/CvHistogram.cs

r31229	r31236
117	117	private set;
118	118	}
	119	/// <summary>
	120	/// ヒストグラムのビン(値域)を取得する.
	121	/// TypeがArrayならCvMatND, SparseならCvSparseMatが返される.
	122	/// </summary>
	123	public CvArr Bins
	124	{
	125	get
	126	{
	127	switch (Type)
	128	{
	129	case HistogramFormat.Array:
	130	return new CvMatND(data.bins, false);
	131	case HistogramFormat.Sparse:
	132	return new CvSparseMat(data.bins, false);
	133	default:
	134	throw new Exception();
	135	}
	136	}
	137	}
	138	/// <summary>
	139	/// ヒストグラムの次元
	140	/// </summary>
	141	public int Dim {
	142	get { return data.mat_dims; }
	143	}
119	144	#endregion
120	145
…	…
271	296	}
272	297	#endregion
273		/* #region GetValue*D
	298	#region GetValue*D
274	299	/// <summary>
275	300	/// 1次元ヒストグラムの指定されたビンへのポインタを返す (cvGetHistValue_1D)．
…	…
278	303	/// <param name="idx0">要素インデックスの，0を基準とした第1成分．</param>
279	304	/// <returns>指定した要素のポインタ</returns>
280		~~Single* GetValue1D( Int32~~ idx0 )
281		{
282		return ~~(float*)::cvPtr1D(ptr->bins~~, idx0);
	305	public IntPtr GetValue1D( int idx0 )
	306	{
	307	return CvInline.cvGetHistValue_1D_(ptr, idx0);
283	308	}
284	309	/// <summary>
…	…
289	314	/// <param name="idx1">要素インデックスの，0を基準とした第2成分．</param>
290	315	/// <returns>指定した要素のポインタ</returns>
291		~~Single* GetValue2D( Int32 idx0, Int32~~ idx1 )
292		{
293		~~return (float*)::cvPtr2D(ptr->bins~~, idx0, idx1);
	316	public IntPtr GetValue2D( int idx0, int idx1 )
	317	{
	318	return CvInline.cvGetHistValue_2D_(ptr, idx0, idx1);
294	319	}
295	320	/// <summary>
…	…
301	326	/// <param name="idx2">要素インデックスの，0を基準とした第3成分．</param>
302	327	/// <returns>指定した要素のポインタ</returns>
303		~~Single* GetValue3D( Int32 idx0, Int32 idx1, Int32~~ idx2 )
304		{
305		~~return (float*)::cvPtr3D(ptr->bins~~, idx0, idx1, idx2);
	328	public IntPtr GetValue3D( int idx0, int idx1, int idx2 )
	329	{
	330	return CvInline.cvGetHistValue_3D_(ptr, idx0, idx1, idx2);
306	331	}
307	332	/// <summary>
…	…
311	336	/// <param name="idx">要素インデックスの配列(可変長引数)</param>
312	337	/// <returns>指定した要素のポインタ</returns>
313		Single* GetValueND( ... array<Int32>^ idx )
314		{
315		pin_ptr<int> idx_ptr = &idx[0];
316		return (Single*)::cvPtrND(ptr->bins, idx_ptr);
	338	public IntPtr GetValueND( params int[] idx )
	339	{
	340	return CvInline.cvGetHistValue_nD_(ptr, idx);
317	341	}
318	342	#endregion
…	…
324	348	/// <param name="min_value">ヒストグラムの最小値の出力</param>
325	349	/// <param name="max_value">ヒストグラムの最大値の出力</param>
326		~~void GetMinMaxValue( [Out] Single% min_value, [Out] Single%~~ max_value )
327		{
328		~~Cv::GetMinMaxHistValue(this, min_value,~~ max_value);
	350	public void GetMinMaxValue( out float min_value, out float max_value )
	351	{
	352	Cv.GetMinMaxHistValue(this, out min_value, out max_value);
329	353	}
330	354	/// <summary>
…	…
336	360	/// <param name="min_idx">最小値の配列中のインデックスの出力</param>
337	361	/// <param name="max_idx">最大値の配列中のインデックスの出力</param>
338		~~void GetMinMaxValue( [Out] Single% min_value, [Out] Single% max_value, [Out] Int32% min_idx, [Out] Int32%~~ max_idx )
339		{
340		~~Cv::GetMinMaxHistValue(this, min_value, max_value, min_idx,~~ max_idx);
341		}
342		#endregion */
	362	public void GetMinMaxValue( out float min_value, out float max_value, out int[] min_idx, out int[] max_idx )
	363	{
	364	Cv.GetMinMaxHistValue(this, out min_value, out max_value, out min_idx, out max_idx);
	365	}
	366	#endregion
343	367	#region Normalize
344	368	/// <summary>

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

r31229	r31236
62	62	public static extern void cvCopyMakeBorder(IntPtr src, IntPtr dst, CvPoint offset, BorderType bordertype, CvScalar value);
63	63	[DllImport(DLL_CV)]
	64	public static extern IntPtr cvCreateHist(int dims, int[] sizes, HistogramFormat type, IntPtr[] ranges, int uniform);
	65	[DllImport(DLL_CV)]
	66	public static extern IntPtr cvCreateHist(int dims, int[] sizes, HistogramFormat type, IntPtr ranges, int uniform);
	67	[DllImport(DLL_CV)]
64	68	public static extern IntPtr cvCreateSubdiv2D([MarshalAs(UnmanagedType.U4)] SeqType subdiv_type, int header_size, int vtx_size, int quadedge_size, IntPtr storage);
65	69	[DllImport(DLL_CV)]
…	…
73	77	[DllImport(DLL_CV)]
74	78	public static extern IntPtr cvGetAffineTransform(CvPoint2D32f[] src, CvPoint2D32f[] dst, IntPtr map_matrix);
	79	[DllImport(DLL_CV)]
	80	public static extern void cvGetMinMaxHistValue(IntPtr hist, ref float minValue, ref float maxValue, int[] minIdx, int[] maxIdx);
75	81	[DllImport(DLL_CV)]
76	82	public static extern void cvInitSubdivDelaunay2D(IntPtr subdiv, CvRect rect);
…	…
124	130	public static extern void cvCircle(IntPtr img, CvPoint center, int radius, CvScalar color, int thickness, [MarshalAs(UnmanagedType.U4)] LineType line_type, int shift);
125	131	[DllImport(DLL_CXCORE)]
126		~~public static extern IntPtr cvCreateHist(int dims, int[] sizes, HistogramFormat type, IntPtr[] ranges, int uniform);~~
127		~~[DllImport(DLL_CXCORE)]~~
128		~~public static extern IntPtr cvCreateHist(int dims, int[] sizes, HistogramFormat type, IntPtr ranges, int uniform);~~
129		~~[DllImport(DLL_CXCORE)]~~
130	132	public static extern void cvClearSeq(IntPtr seq);
131	133	[DllImport(DLL_CXCORE)]
…	…
218	220	public static extern void cvLog(IntPtr src, IntPtr dst);
219	221	[DllImport(DLL_CXCORE)]
	222	public static extern void cvLUT(IntPtr src, IntPtr dst, IntPtr lut);
	223	[DllImport(DLL_CXCORE)]
220	224	public static extern void cvMax(IntPtr src1, IntPtr src2, IntPtr dst);
221	225	[DllImport(DLL_CXCORE)]
…	…
263	267	[DllImport(DLL_CXCORE)]
264	268	public static extern void cvReleaseMemStorage(ref IntPtr storage);
	269	[DllImport(DLL_CXCORE)]
	270	public static extern void cvReleaseSparseMat(ref IntPtr mat);
265	271	[DllImport(DLL_CXCORE)]
266	272	public static extern void cvResetImageROI(IntPtr image);
…	…
457	463	static N::CvStringHashNode^ GetHashedKey( N::CvFileStorage^ fs, String^ name, Boolean create_missing );
458	464	static int GetImageCOI( N::IplImage^ image );
459		~~static void GetMinMaxHistValue( N::CvHistogram^ hist, [Out] Single% min_value, [Out] Single% max_value, [Out] int% min_idx, [Out] int% max_idx );~~
460	465	static N::CvMat^ GetPerspectiveTransform( array<N::CvPoint2D32f>^ src, array<N::CvPoint2D32f>^ dst, [Out] N::CvMat^ map_matrix );
461	466	static void GetQuadrangleSubPix( N::CvArr^ src, N::CvArr^ dst, N::CvMat^ map_matrix );
…	…
482	487	static T Load( String^ filename, N::CvMemStorage^ memstorage, String^ name, array<String^>^ real_name );
483	488	static void LogPolar( N::CvArr^ src, N::CvArr^ dst, N::CvPoint2D32f center, Double M, Interpolation flags );
484		~~static void LUT( N::CvArr^ src, N::CvArr^ dst, array<Double>^ lut );~~
485	489	static N::CvMat^ Mat( int rows, int cols, MatrixType type, array<Double>^ data );
486	490	static void MatchTemplate( N::CvArr^ image, N::CvArr^ templ, N::CvArr^ result, TemplateMatching method );

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Core/Cv_Cv.cs

r31229	r31236
756	756	}
757	757	#endregion
	758	#region GetHistValue_*D
	759	/// <summary>
	760	/// 1次元ヒストグラムの指定されたビンへのポインタを返す．
	761	/// 疎なヒストグラムの場合で，既にビンが存在している場合以外は，この関数が新しいビンを作成し，0にセットする．
	762	/// </summary>
	763	/// <param name="hist">ヒストグラム</param>
	764	/// <param name="idx0">要素インデックスの，0を基準とした第1成分．</param>
	765	/// <returns>指定した要素のポインタ</returns>
	766	public static IntPtr GetHistValue_1D( CvHistogram hist, int idx0 )
	767	{
	768	return CvInline.cvGetHistValue_1D_(hist.CvPtr, idx0);
	769	}
	770	/// <summary>
	771	/// 2次元ヒストグラムの指定されたビンへのポインタを返す．
	772	/// 疎なヒストグラムの場合で，既にビンが存在している場合以外は，この関数が新しいビンを作成し，0にセットする．
	773	/// </summary>
	774	/// <param name="hist">ヒストグラム</param>
	775	/// <param name="idx0">要素インデックスの，0を基準とした第1成分．</param>
	776	/// <param name="idx1">要素インデックスの，0を基準とした第2成分．</param>
	777	/// <returns>指定した要素のポインタ</returns>
	778	public static IntPtr GetHistValue_2D( CvHistogram hist, int idx0, int idx1 )
	779	{
	780	return CvInline.cvGetHistValue_2D_(hist.CvPtr, idx0, idx1);
	781	}
	782	/// <summary>
	783	/// 3次元ヒストグラムの指定されたビンへのポインタを返す．
	784	/// 疎なヒストグラムの場合で，既にビンが存在している場合以外は，この関数が新しいビンを作成し，0にセットする．
	785	/// </summary>
	786	/// <param name="hist">ヒストグラム</param>
	787	/// <param name="idx0">要素インデックスの，0を基準とした第1成分．</param>
	788	/// <param name="idx1">要素インデックスの，0を基準とした第2成分．</param>
	789	/// <param name="idx2">要素インデックスの，0を基準とした第3成分．</param>
	790	/// <returns>指定した要素のポインタ</returns>
	791	public static IntPtr GetHistValue_3D( CvHistogram hist, int idx0, int idx1, int idx2 )
	792	{
	793	return CvInline.cvGetHistValue_3D_(hist.CvPtr, idx0, idx1, idx2);
	794	}
	795	/// <summary>
	796	/// n次元ヒストグラムの指定されたビンへのポインタを返す．
	797	/// 疎なヒストグラムの場合で，既にビンが存在している場合以外は，この関数が新しいビンを作成し，0にセットする．
	798	/// </summary>
	799	/// <param name="hist">ヒストグラム</param>
	800	/// <param name="idx">要素インデックスの配列(可変長引数)</param>
	801	/// <returns>指定した要素のポインタ</returns>
	802	public static IntPtr GetHistValue_nD( CvHistogram hist, params int[] idx )
	803	{
	804	return CvInline.cvGetHistValue_nD_(hist.CvPtr, idx);
	805	}
	806	#endregion
	807	#region GetMinMaxHistValue
	808	/// <summary>
	809	/// ヒストグラムのビンの最小値/最大値を求める．
	810	/// 同じ値の最大値や最小値が複数存在する場合，辞書順に並べたときに最も先頭になるインデックスが返される．
	811	/// </summary>
	812	/// <param name="hist">ヒストグラム</param>
	813	/// <param name="min_value">ヒストグラムの最小値の出力</param>
	814	/// <param name="max_value">ヒストグラムの最大値の出力</param>
	815	public static void GetMinMaxHistValue(CvHistogram hist, out float min_value, out float max_value)
	816	{
	817	int[] min_idx, max_idx;
	818	GetMinMaxHistValue(hist, out min_value, out max_value, out min_idx, out max_idx);
	819	}
	820	/// <summary>
	821	/// ヒストグラムのビンの最小値/最大値とそれらの場所を求める．
	822	/// 同じ値の最大値や最小値が複数存在する場合，辞書順に並べたときに最も先頭になるインデックスが返される．
	823	/// </summary>
	824	/// <param name="hist">ヒストグラム</param>
	825	/// <param name="min_value">ヒストグラムの最小値の出力</param>
	826	/// <param name="max_value">ヒストグラムの最大値の出力</param>
	827	/// <param name="min_idx">最小値の配列中のインデックスの出力</param>
	828	/// <param name="max_idx">最大値の配列中のインデックスの出力</param>
	829	public static void GetMinMaxHistValue( CvHistogram hist, out float min_value, out float max_value, out int[] min_idx, out int[] max_idx )
	830	{
	831	if(hist == null)
	832	{
	833	throw new ArgumentNullException("hist");
	834	}
	835	float _min_value = 0;
	836	float _max_value = 0;
	837	int[] _min_idx = new int[hist.Dim];
	838	int[] _max_idx = new int[hist.Dim];
	839	CvDll.cvGetMinMaxHistValue(hist.CvPtr, ref _min_value, ref _max_value, _min_idx, _max_idx);
	840	min_value = _min_value;
	841	max_value = _max_value;
	842	min_idx = _min_idx;
	843	max_idx = _max_idx;
	844	}
	845	#endregion
758	846	#region GetSeqReaderPos
759	847	/// <summary>

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/Core/Cv_CxCore.cs

r31229	r31236
1598	1598	}
1599	1599	#endregion
	1600	#region LUT
	1601	/// <summary>
	1602	/// 出力配列の各要素値をルックアップテーブルを用いて決定する．
	1603	/// </summary>
	1604	/// <param name="src">入力配列（各要素は8ビットデータ）．</param>
	1605	/// <param name="dst">出力配列（任意のデプス，入力配列と同じチャンネル数）．</param>
	1606	/// <param name="lut">要素数が256であるルックアップテーブル（出力配列と同じデプスでなければならない）．マルチチャンネルの入力/出力配列の場合，テーブルはシングルチャンネル（この場合すべてのチャンネル対して，同じテーブルを使う）か，入力/出力配列と同じチャンネル数でなければならない．</param>
	1607	public static void LUT(this CvArr src, CvArr dst, CvArr lut)
	1608	{
	1609	if (src == null)
	1610	throw new ArgumentNullException("src");
	1611	if (dst == null)
	1612	throw new ArgumentNullException("dst");
	1613	if (lut == null)
	1614	throw new ArgumentNullException("lut");
	1615	CvDll.cvLUT(src.CvPtr, dst.CvPtr, lut.CvPtr);
	1616	}
	1617	/// <summary>
	1618	/// 出力配列の各要素値をルックアップテーブルを用いて決定する．ルックアップテーブルが配列で指定できる簡易バージョン.
	1619	/// </summary>
	1620	/// <param name="src">入力配列（各要素は8ビットデータ）</param>
	1621	/// <param name="dst">出力配列（任意のデプス，入力配列と同じチャンネル数）</param>
	1622	/// <param name="lut">要素数が256であるルックアップテーブル</param>
	1623	public static void LUT(this CvArr src, CvArr dst, byte[] lut)
	1624	{
	1625	if (src == null)
	1626	throw new ArgumentNullException("src");
	1627	if (dst == null)
	1628	throw new ArgumentNullException("dst");
	1629	if (lut == null)
	1630	throw new ArgumentNullException("lut");
	1631	if (lut.Length != 256)
	1632	throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
	1633	if (dst.ElemChannels != 1)
	1634	{
	1635	throw new NotImplementedException();
	1636	}
	1637
	1638	using (CvMat lutMat = new CvMat(256, 1, MatrixType.U8C1, lut))
	1639	{
	1640	CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
	1641	}
	1642	}
	1643	/// <summary>
	1644	/// 出力配列の各要素値をルックアップテーブルを用いて決定する．ルックアップテーブルが配列で指定できる簡易バージョン.
	1645	/// </summary>
	1646	/// <param name="src">入力配列（各要素は8ビットデータ）</param>
	1647	/// <param name="dst">出力配列（任意のデプス，入力配列と同じチャンネル数）</param>
	1648	/// <param name="lut">要素数が256であるルックアップテーブル</param>
	1649	public static void LUT(this CvArr src, CvArr dst, Int16[] lut)
	1650	{
	1651	if (src == null)
	1652	throw new ArgumentNullException("src");
	1653	if (dst == null)
	1654	throw new ArgumentNullException("dst");
	1655	if (lut == null)
	1656	throw new ArgumentNullException("lut");
	1657	if (lut.Length != 256)
	1658	throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
	1659	if (dst.ElemChannels != 1)
	1660	{
	1661	throw new NotImplementedException();
	1662	}
	1663
	1664	using (CvMat lutMat = new CvMat(256, 1, MatrixType.S16C1, lut))
	1665	{
	1666	CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
	1667	}
	1668	}
	1669	/// <summary>
	1670	/// 出力配列の各要素値をルックアップテーブルを用いて決定する．ルックアップテーブルが配列で指定できる簡易バージョン.
	1671	/// </summary>
	1672	/// <param name="src">入力配列（各要素は8ビットデータ）</param>
	1673	/// <param name="dst">出力配列（任意のデプス，入力配列と同じチャンネル数）</param>
	1674	/// <param name="lut">要素数が256であるルックアップテーブル</param>
	1675	public static void LUT(CvArr src, CvArr dst, Int32[] lut)
	1676	{
	1677	if (src == null)
	1678	throw new ArgumentNullException("src");
	1679	if (dst == null)
	1680	throw new ArgumentNullException("dst");
	1681	if (lut == null)
	1682	throw new ArgumentNullException("lut");
	1683	if (lut.Length != 256)
	1684	throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
	1685	if (dst.ElemChannels != 1)
	1686	{
	1687	throw new NotImplementedException();
	1688	}
	1689
	1690	using (CvMat lutMat = new CvMat(256, 1, MatrixType.S32C1, lut))
	1691	{
	1692	CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
	1693	}
	1694	}
	1695	/// <summary>
	1696	/// 出力配列の各要素値をルックアップテーブルを用いて決定する．ルックアップテーブルが配列で指定できる簡易バージョン.
	1697	/// </summary>
	1698	/// <param name="src">入力配列（各要素は8ビットデータ）</param>
	1699	/// <param name="dst">出力配列（任意のデプス，入力配列と同じチャンネル数）</param>
	1700	/// <param name="lut">要素数が256であるルックアップテーブル</param>
	1701	public static void LUT(CvArr src, CvArr dst, float[] lut)
	1702	{
	1703	if (src == null)
	1704	throw new ArgumentNullException("src");
	1705	if (dst == null)
	1706	throw new ArgumentNullException("dst");
	1707	if (lut == null)
	1708	throw new ArgumentNullException("lut");
	1709	if (lut.Length != 256)
	1710	throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
	1711	if (dst.ElemChannels != 1)
	1712	{
	1713	throw new NotImplementedException();
	1714	}
	1715
	1716	using (CvMat lutMat = new CvMat(256, 1, MatrixType.F32C1, lut))
	1717	{
	1718	CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
	1719	}
	1720	}
	1721	/// <summary>
	1722	/// 出力配列の各要素値をルックアップテーブルを用いて決定する．ルックアップテーブルが配列で指定できる簡易バージョン.
	1723	/// </summary>
	1724	/// <param name="src">入力配列（各要素は8ビットデータ）</param>
	1725	/// <param name="dst">出力配列（任意のデプス，入力配列と同じチャンネル数）</param>
	1726	/// <param name="lut">要素数が256であるルックアップテーブル</param>
	1727	public static void LUT(CvArr src, CvArr dst, double[] lut)
	1728	{
	1729	if (src == null)
	1730	throw new ArgumentNullException("src");
	1731	if (dst == null)
	1732	throw new ArgumentNullException("dst");
	1733	if (lut == null)
	1734	throw new ArgumentNullException("lut");
	1735	if (lut.Length != 256)
	1736	throw new ArgumentOutOfRangeException("lut", "lut.Length must be 256");
	1737	if (dst.ElemChannels != 1)
	1738	{
	1739	throw new NotImplementedException();
	1740	}
	1741
	1742	using (CvMat lutMat = new CvMat(256, 1, MatrixType.F64C1, lut))
	1743	{
	1744	CvDll.cvLUT(src.CvPtr, dst.CvPtr, lutMat.CvPtr);
	1745	}
	1746	}
	1747	#endregion
1600	1748	#region Max
1601	1749	/// <summary>
…	…
2313	2461	}
2314	2462	#endregion
	2463	#region ReleaseMatND
	2464	/// <summary>
	2465	/// CvMatNDを解放する
	2466	/// </summary>
	2467	/// <param name="mat">行列への参照</param>
	2468	public static void ReleaseMatND(CvMatND mat)
	2469	{
	2470	if (mat == null)
	2471	{
	2472	throw new ArgumentNullException("mat");
	2473	}
	2474	mat.Dispose();
	2475	}
	2476	#endregion
2315	2477	#region ReleaseMemStorage
2316	2478	/// <summary>
…	…
2327	2489	}
2328	2490	storage.Dispose();
	2491	}
	2492	#endregion
	2493	#region ReleaseSparseMat
	2494	/// <summary>
	2495	/// CvSparseMatを解放する
	2496	/// </summary>
	2497	/// <param name="mat">行列への参照</param>
	2498	public static void ReleaseMatND(CvSparseMat mat)
	2499	{
	2500	if (mat == null)
	2501	{
	2502	throw new ArgumentNullException("mat");
	2503	}
	2504	mat.Dispose();
2329	2505	}
2330	2506	#endregion

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/CvArr/CvArr.cs

r31203	r31236
106	106	}
107	107	}
	108	/// <summary>
	109	/// 配列要素のタイプを取得する.
	110	/// </summary>
	111	public virtual int ElemDepth
	112	{
	113	get
	114	{
	115	switch (ElemType)
	116	{
	117	case MatrixType.U8C1:
	118	case MatrixType.U8C2:
	119	case MatrixType.U8C3:
	120	case MatrixType.U8C4:
	121	case MatrixType.S8C1:
	122	case MatrixType.S8C2:
	123	case MatrixType.S8C3:
	124	case MatrixType.S8C4:
	125	return 8;
	126	case MatrixType.U16C1:
	127	case MatrixType.U16C2:
	128	case MatrixType.U16C3:
	129	case MatrixType.U16C4:
	130	case MatrixType.S16C1:
	131	case MatrixType.S16C2:
	132	case MatrixType.S16C3:
	133	case MatrixType.S16C4:
	134	return 16;
	135	case MatrixType.F32C1:
	136	case MatrixType.F32C2:
	137	case MatrixType.F32C3:
	138	case MatrixType.F32C4:
	139	case MatrixType.S32C1:
	140	case MatrixType.S32C2:
	141	case MatrixType.S32C3:
	142	case MatrixType.S32C4:
	143	return 32;
	144	case MatrixType.F64C1:
	145	case MatrixType.F64C2:
	146	case MatrixType.F64C3:
	147	case MatrixType.F64C4:
	148	return 64;
	149	default:
	150	// んなバカな
	151	throw new OpenCvSharpException();
	152	}
	153	}
	154	}
108	155
109	156	/// <summary>

lang/cpluspluscli/OpenCvSharp2/trunk/OpenCvSharp/OpenCvSharp.csproj

r31229	r31236
95	95	<Compile Include="CvArr\CvMat.cs" />
96	96	<Compile Include="Class\CvMemStorage.cs" />
	97	<Compile Include="CvArr\CvMatND.cs" />
97	98	<Compile Include="CvArr\CvSeq.cs" />
98	99	<Compile Include="CvArr\CvSet.cs" />
99	100	<Compile Include="Class\CvSeqReader.cs" />
	101	<Compile Include="CvArr\CvSparseMat.cs" />
100	102	<Compile Include="Delegate\CvComparison.cs" />
101	103	<Compile Include="Delegate\CvMouseCallbackhandler.cs" />

Download in other formats: