1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #include "_cxcore.h"
43
44 /****************************************************************************************\
45 * LUT Transform *
46 \****************************************************************************************/
47
48 #define ICV_LUT_CASE_C1( type ) \
49 for( i = 0; i <= size.width-4; i += 4 ) \
50 { \
51 type t0 = lut[src[i]]; \
52 type t1 = lut[src[i+1]]; \
53 dst[i] = t0; \
54 dst[i+1] = t1; \
55 \
56 t0 = lut[src[i+2]]; \
57 t1 = lut[src[i+3]]; \
58 dst[i+2] = t0; \
59 dst[i+3] = t1; \
60 } \
61 \
62 for( ; i < size.width; i++ ) \
63 { \
64 type t0 = lut[src[i]]; \
65 dst[i] = t0; \
66 }
67
68
69 #define ICV_LUT_CASE_C2( type ) \
70 for( i = 0; i < size.width; i += 2 ) \
71 { \
72 type t0 = lut[src[i]*2]; \
73 type t1 = lut[src[i+1]*2 + 1]; \
74 dst[i] = t0; \
75 dst[i+1] = t1; \
76 }
77
78 #define ICV_LUT_CASE_C3( type ) \
79 for( i = 0; i < size.width; i += 3 ) \
80 { \
81 type t0 = lut[src[i]*3]; \
82 type t1 = lut[src[i+1]*3 + 1]; \
83 type t2 = lut[src[i+2]*3 + 2]; \
84 dst[i] = t0; \
85 dst[i+1] = t1; \
86 dst[i+2] = t2; \
87 }
88
89 #define ICV_LUT_CASE_C4( type ) \
90 for( i = 0; i < size.width; i += 4 ) \
91 { \
92 type t0 = lut[src[i]*4]; \
93 type t1 = lut[src[i+1]*4 + 1]; \
94 dst[i] = t0; \
95 dst[i+1] = t1; \
96 t0 = lut[src[i+2]*4 + 2]; \
97 t1 = lut[src[i+3]*4 + 3]; \
98 dst[i+2] = t0; \
99 dst[i+3] = t1; \
100 }
101
102
103 #define ICV_DEF_LUT_FUNC_8U_CN( flavor, dsttype, cn ) \
104 CvStatus CV_STDCALL icvLUT_Transform8u_##flavor##_C##cn##R( \
105 const uchar* src, int srcstep, \
106 dsttype* dst, int dststep, CvSize size, \
107 const dsttype* lut ) \
108 { \
109 size.width *= cn; \
110 dststep /= sizeof(dst[0]); \
111 for( ; size.height--; src += srcstep, dst += dststep ) \
112 { \
113 int i; \
114 ICV_LUT_CASE_C##cn( dsttype ) \
115 } \
116 \
117 return CV_OK; \
118 }
119
120
121 ICV_DEF_LUT_FUNC_8U_CN( 8u, uchar, 1 )
122 ICV_DEF_LUT_FUNC_8U_CN( 16u, ushort, 1 )
123 ICV_DEF_LUT_FUNC_8U_CN( 32s, int, 1 )
124 ICV_DEF_LUT_FUNC_8U_CN( 64f, double, 1 )
125
126 ICV_DEF_LUT_FUNC_8U_CN( 8u, uchar, 2 )
127 ICV_DEF_LUT_FUNC_8U_CN( 8u, uchar, 3 )
128 ICV_DEF_LUT_FUNC_8U_CN( 8u, uchar, 4 )
129
130
131 #define ICV_DEF_LUT_FUNC_8U( flavor, dsttype ) \
132 static CvStatus CV_STDCALL \
133 icvLUT_Transform8u_##flavor##_CnR( \
134 const uchar* src, int srcstep, \
135 dsttype* dst, int dststep, CvSize size, \
136 const dsttype* _lut, int cn ) \
137 { \
138 int max_block_size = (1 << 10)*cn; \
139 dsttype lutp[1024]; \
140 int i, k; \
141 \
142 size.width *= cn; \
143 dststep /= sizeof(dst[0]); \
144 \
145 if( size.width*size.height < 256 ) \
146 { \
147 for( ; size.height--; src+=srcstep, dst+=dststep ) \
148 for( k = 0; k < cn; k++ ) \
149 for( i = 0; i < size.width; i += cn ) \
150 dst[i+k] = _lut[src[i+k]*cn+k]; \
151 return CV_OK; \
152 } \
153 \
154 /* repack the lut to planar layout */ \
155 for( k = 0; k < cn; k++ ) \
156 for( i = 0; i < 256; i++ ) \
157 lutp[i+k*256] = _lut[i*cn+k]; \
158 \
159 for( ; size.height--; src += srcstep, dst += dststep ) \
160 { \
161 for( i = 0; i < size.width; ) \
162 { \
163 int j, limit = MIN(size.width,i+max_block_size);\
164 for( k=0; k<cn; k++, src++, dst++ ) \
165 { \
166 const dsttype* lut = lutp + k*256; \
167 for( j = i; j <= limit - cn*2; j += cn*2 ) \
168 { \
169 dsttype t0 = lut[src[j]]; \
170 dsttype t1 = lut[src[j+cn]]; \
171 dst[j] = t0; dst[j+cn] = t1; \
172 } \
173 \
174 for( ; j < limit; j += cn ) \
175 dst[j] = lut[src[j]]; \
176 } \
177 src -= cn; \
178 dst -= cn; \
179 i += limit; \
180 } \
181 } \
182 \
183 return CV_OK; \
184 }
185
186 ICV_DEF_LUT_FUNC_8U( 8u, uchar )
187 ICV_DEF_LUT_FUNC_8U( 16u, ushort )
188 ICV_DEF_LUT_FUNC_8U( 32s, int )
189 ICV_DEF_LUT_FUNC_8U( 64f, double )
190
191 #undef icvLUT_Transform8u_8s_C1R
192 #undef icvLUT_Transform8u_16s_C1R
193 #undef icvLUT_Transform8u_32f_C1R
194
195 #define icvLUT_Transform8u_8s_C1R icvLUT_Transform8u_8u_C1R
196 #define icvLUT_Transform8u_16s_C1R icvLUT_Transform8u_16u_C1R
197 #define icvLUT_Transform8u_32f_C1R icvLUT_Transform8u_32s_C1R
198
199 #define icvLUT_Transform8u_8s_CnR icvLUT_Transform8u_8u_CnR
200 #define icvLUT_Transform8u_16s_CnR icvLUT_Transform8u_16u_CnR
201 #define icvLUT_Transform8u_32f_CnR icvLUT_Transform8u_32s_CnR
202
203 CV_DEF_INIT_FUNC_TAB_2D( LUT_Transform8u, C1R )
204 CV_DEF_INIT_FUNC_TAB_2D( LUT_Transform8u, CnR )
205
206 typedef CvStatus (CV_STDCALL * CvLUT_TransformCnFunc)(
207 const void* src, int srcstep, void* dst,
208 int dststep, CvSize size, const void* lut, int cn );
209
210 CV_IMPL void
cvLUT(const void * srcarr,void * dstarr,const void * lutarr)211 cvLUT( const void* srcarr, void* dstarr, const void* lutarr )
212 {
213 static CvFuncTable lut_c1_tab, lut_cn_tab;
214 static CvLUT_TransformFunc lut_8u_tab[4];
215 static int inittab = 0;
216
217 CV_FUNCNAME( "cvLUT" );
218
219 __BEGIN__;
220
221 int coi1 = 0, coi2 = 0;
222 int depth, cn, lut_cn;
223 CvMat srcstub, *src = (CvMat*)srcarr;
224 CvMat dststub, *dst = (CvMat*)dstarr;
225 CvMat lutstub, *lut = (CvMat*)lutarr;
226 uchar* lut_data;
227 uchar* shuffled_lut = 0;
228 CvSize size;
229
230 if( !inittab )
231 {
232 icvInitLUT_Transform8uC1RTable( &lut_c1_tab );
233 icvInitLUT_Transform8uCnRTable( &lut_cn_tab );
234 lut_8u_tab[0] = (CvLUT_TransformFunc)icvLUT_Transform8u_8u_C1R;
235 lut_8u_tab[1] = (CvLUT_TransformFunc)icvLUT_Transform8u_8u_C2R;
236 lut_8u_tab[2] = (CvLUT_TransformFunc)icvLUT_Transform8u_8u_C3R;
237 lut_8u_tab[3] = (CvLUT_TransformFunc)icvLUT_Transform8u_8u_C4R;
238 inittab = 1;
239 }
240
241 if( !CV_IS_MAT(src) )
242 CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
243
244 if( !CV_IS_MAT(dst) )
245 CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));
246
247 if( !CV_IS_MAT(lut) )
248 CV_CALL( lut = cvGetMat( lut, &lutstub ));
249
250 if( coi1 != 0 || coi2 != 0 )
251 CV_ERROR( CV_BadCOI, "" );
252
253 if( !CV_ARE_SIZES_EQ( src, dst ))
254 CV_ERROR( CV_StsUnmatchedSizes, "" );
255
256 if( !CV_ARE_CNS_EQ( src, dst ))
257 CV_ERROR( CV_StsUnmatchedFormats, "" );
258
259 if( CV_MAT_DEPTH( src->type ) > CV_8S )
260 CV_ERROR( CV_StsUnsupportedFormat, "" );
261
262 depth = CV_MAT_DEPTH( dst->type );
263 cn = CV_MAT_CN( dst->type );
264 lut_cn = CV_MAT_CN( lut->type );
265
266 if( !CV_IS_MAT_CONT(lut->type) || (lut_cn != 1 && lut_cn != cn) ||
267 !CV_ARE_DEPTHS_EQ( dst, lut ) || lut->width*lut->height != 256 )
268 CV_ERROR( CV_StsBadArg, "The LUT must be continuous array \n"
269 "with 256 elements of the same type as destination" );
270
271 size = cvGetMatSize( src );
272 if( lut_cn == 1 )
273 {
274 size.width *= cn;
275 cn = 1;
276 }
277
278 if( CV_IS_MAT_CONT( src->type & dst->type ))
279 {
280 size.width *= size.height;
281 size.height = 1;
282 }
283
284 lut_data = lut->data.ptr;
285
286 if( CV_MAT_DEPTH( src->type ) == CV_8S )
287 {
288 int half_size = CV_ELEM_SIZE1(depth)*cn*128;
289 shuffled_lut = (uchar*)cvStackAlloc(half_size*2);
290
291 // shuffle lut
292 memcpy( shuffled_lut, lut_data + half_size, half_size );
293 memcpy( shuffled_lut + half_size, lut_data, half_size );
294
295 lut_data = shuffled_lut;
296 }
297
298 if( lut_cn == 1 || (lut_cn <= 4 && depth == CV_8U) )
299 {
300 CvLUT_TransformFunc func = depth == CV_8U ? lut_8u_tab[cn-1] :
301 (CvLUT_TransformFunc)(lut_c1_tab.fn_2d[depth]);
302
303 if( !func )
304 CV_ERROR( CV_StsUnsupportedFormat, "" );
305
306 IPPI_CALL( func( src->data.ptr, src->step, dst->data.ptr,
307 dst->step, size, lut_data ));
308 }
309 else
310 {
311 CvLUT_TransformCnFunc func =
312 (CvLUT_TransformCnFunc)(lut_cn_tab.fn_2d[depth]);
313
314 if( !func )
315 CV_ERROR( CV_StsUnsupportedFormat, "" );
316
317 IPPI_CALL( func( src->data.ptr, src->step, dst->data.ptr,
318 dst->step, size, lut_data, cn ));
319 }
320
321 __END__;
322 }
323
324 /* End of file. */
325