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 "_cv.h"
43
cvPointSeqFromMat(int seq_kind,const CvArr * arr,CvContour * contour_header,CvSeqBlock * block)44 CV_IMPL CvSeq* cvPointSeqFromMat( int seq_kind, const CvArr* arr,
45 CvContour* contour_header, CvSeqBlock* block )
46 {
47 CvSeq* contour = 0;
48
49 CV_FUNCNAME( "cvPointSeqFromMat" );
50
51 assert( arr != 0 && contour_header != 0 && block != 0 );
52
53 __BEGIN__;
54
55 int eltype;
56 CvMat* mat = (CvMat*)arr;
57
58 if( !CV_IS_MAT( mat ))
59 CV_ERROR( CV_StsBadArg, "Input array is not a valid matrix" );
60
61 eltype = CV_MAT_TYPE( mat->type );
62 if( eltype != CV_32SC2 && eltype != CV_32FC2 )
63 CV_ERROR( CV_StsUnsupportedFormat,
64 "The matrix can not be converted to point sequence because of "
65 "inappropriate element type" );
66
67 if( (mat->width != 1 && mat->height != 1) || !CV_IS_MAT_CONT(mat->type))
68 CV_ERROR( CV_StsBadArg,
69 "The matrix converted to point sequence must be "
70 "1-dimensional and continuous" );
71
72 CV_CALL( cvMakeSeqHeaderForArray(
73 (seq_kind & (CV_SEQ_KIND_MASK|CV_SEQ_FLAG_CLOSED)) | eltype,
74 sizeof(CvContour), CV_ELEM_SIZE(eltype), mat->data.ptr,
75 mat->width*mat->height, (CvSeq*)contour_header, block ));
76
77 contour = (CvSeq*)contour_header;
78
79 __END__;
80
81 return contour;
82 }
83
84
85 typedef CvStatus (CV_STDCALL * CvCopyNonConstBorderFunc)(
86 const void*, int, CvSize, void*, int, CvSize, int, int );
87
88 typedef CvStatus (CV_STDCALL * CvCopyNonConstBorderFuncI)(
89 const void*, int, CvSize, CvSize, int, int );
90
91 icvCopyReplicateBorder_8u_C1R_t icvCopyReplicateBorder_8u_C1R_p = 0;
92 icvCopyReplicateBorder_16s_C1R_t icvCopyReplicateBorder_16s_C1R_p = 0;
93 icvCopyReplicateBorder_8u_C3R_t icvCopyReplicateBorder_8u_C3R_p = 0;
94 icvCopyReplicateBorder_32s_C1R_t icvCopyReplicateBorder_32s_C1R_p = 0;
95 icvCopyReplicateBorder_16s_C3R_t icvCopyReplicateBorder_16s_C3R_p = 0;
96 icvCopyReplicateBorder_16s_C4R_t icvCopyReplicateBorder_16s_C4R_p = 0;
97 icvCopyReplicateBorder_32s_C3R_t icvCopyReplicateBorder_32s_C3R_p = 0;
98 icvCopyReplicateBorder_32s_C4R_t icvCopyReplicateBorder_32s_C4R_p = 0;
99
100 icvCopyReplicateBorder_8u_C1IR_t icvCopyReplicateBorder_8u_C1IR_p = 0;
101 icvCopyReplicateBorder_16s_C1IR_t icvCopyReplicateBorder_16s_C1IR_p = 0;
102 icvCopyReplicateBorder_8u_C3IR_t icvCopyReplicateBorder_8u_C3IR_p = 0;
103 icvCopyReplicateBorder_32s_C1IR_t icvCopyReplicateBorder_32s_C1IR_p = 0;
104 icvCopyReplicateBorder_16s_C3IR_t icvCopyReplicateBorder_16s_C3IR_p = 0;
105 icvCopyReplicateBorder_16s_C4IR_t icvCopyReplicateBorder_16s_C4IR_p = 0;
106 icvCopyReplicateBorder_32s_C3IR_t icvCopyReplicateBorder_32s_C3IR_p = 0;
107 icvCopyReplicateBorder_32s_C4IR_t icvCopyReplicateBorder_32s_C4IR_p = 0;
108
109
110 CvStatus CV_STDCALL
icvCopyReplicateBorder_8u(const uchar * src,int srcstep,CvSize srcroi,uchar * dst,int dststep,CvSize dstroi,int top,int left,int cn,const uchar *)111 icvCopyReplicateBorder_8u( const uchar* src, int srcstep, CvSize srcroi,
112 uchar* dst, int dststep, CvSize dstroi,
113 int top, int left, int cn, const uchar* )
114 {
115 const int isz = (int)sizeof(int);
116 int i, j;
117
118 if( srcstep == dststep && dst + dststep*top + left*cn == src &&
119 icvCopyReplicateBorder_8u_C1IR_p )
120 {
121 CvCopyNonConstBorderFuncI ifunc =
122 cn == 1 ? icvCopyReplicateBorder_8u_C1IR_p :
123 cn == 2 ? icvCopyReplicateBorder_16s_C1IR_p :
124 cn == 3 ? icvCopyReplicateBorder_8u_C3IR_p :
125 cn == 4 ? icvCopyReplicateBorder_32s_C1IR_p :
126 cn == 6 ? icvCopyReplicateBorder_16s_C3IR_p :
127 cn == 8 ? icvCopyReplicateBorder_16s_C4IR_p :
128 cn == 12 ? icvCopyReplicateBorder_32s_C3IR_p :
129 cn == 16 ? icvCopyReplicateBorder_32s_C4IR_p : 0;
130
131 if( ifunc )
132 return ifunc( src, srcstep, srcroi, dstroi, top, left );
133 }
134 else if( icvCopyReplicateBorder_8u_C1R_p )
135 {
136 CvCopyNonConstBorderFunc func =
137 cn == 1 ? icvCopyReplicateBorder_8u_C1R_p :
138 cn == 2 ? icvCopyReplicateBorder_16s_C1R_p :
139 cn == 3 ? icvCopyReplicateBorder_8u_C3R_p :
140 cn == 4 ? icvCopyReplicateBorder_32s_C1R_p :
141 cn == 6 ? icvCopyReplicateBorder_16s_C3R_p :
142 cn == 8 ? icvCopyReplicateBorder_16s_C4R_p :
143 cn == 12 ? icvCopyReplicateBorder_32s_C3R_p :
144 cn == 16 ? icvCopyReplicateBorder_32s_C4R_p : 0;
145
146 if( func )
147 return func( src, srcstep, srcroi, dst, dststep, dstroi, top, left );
148 }
149
150 if( (cn | srcstep | dststep | (size_t)src | (size_t)dst) % isz == 0 )
151 {
152 const int* isrc = (const int*)src;
153 int* idst = (int*)dst;
154
155 cn /= isz;
156 srcstep /= isz;
157 dststep /= isz;
158
159 srcroi.width *= cn;
160 dstroi.width *= cn;
161 left *= cn;
162
163 for( i = 0; i < dstroi.height; i++, idst += dststep )
164 {
165 if( idst + left != isrc )
166 for( j = 0; j < srcroi.width; j++ )
167 idst[j + left] = isrc[j];
168 for( j = left - 1; j >= 0; j-- )
169 idst[j] = idst[j + cn];
170 for( j = left+srcroi.width; j < dstroi.width; j++ )
171 idst[j] = idst[j - cn];
172 if( i >= top && i < top + srcroi.height - 1 )
173 isrc += srcstep;
174 }
175 }
176 else
177 {
178 srcroi.width *= cn;
179 dstroi.width *= cn;
180 left *= cn;
181
182 for( i = 0; i < dstroi.height; i++, dst += dststep )
183 {
184 if( dst + left != src )
185 for( j = 0; j < srcroi.width; j++ )
186 dst[j + left] = src[j];
187 for( j = left - 1; j >= 0; j-- )
188 dst[j] = dst[j + cn];
189 for( j = left+srcroi.width; j < dstroi.width; j++ )
190 dst[j] = dst[j - cn];
191 if( i >= top && i < top + srcroi.height - 1 )
192 src += srcstep;
193 }
194 }
195
196 return CV_OK;
197 }
198
199
200 static CvStatus CV_STDCALL
icvCopyReflect101Border_8u(const uchar * src,int srcstep,CvSize srcroi,uchar * dst,int dststep,CvSize dstroi,int top,int left,int cn)201 icvCopyReflect101Border_8u( const uchar* src, int srcstep, CvSize srcroi,
202 uchar* dst, int dststep, CvSize dstroi,
203 int top, int left, int cn )
204 {
205 const int isz = (int)sizeof(int);
206 int i, j, k, t, dj, tab_size, int_mode = 0;
207 const int* isrc = (const int*)src;
208 int* idst = (int*)dst, *tab;
209
210 if( (cn | srcstep | dststep | (size_t)src | (size_t)dst) % isz == 0 )
211 {
212 cn /= isz;
213 srcstep /= isz;
214 dststep /= isz;
215
216 int_mode = 1;
217 }
218
219 srcroi.width *= cn;
220 dstroi.width *= cn;
221 left *= cn;
222
223 tab_size = dstroi.width - srcroi.width;
224 tab = (int*)cvStackAlloc( tab_size*sizeof(tab[0]) );
225
226 if( srcroi.width == 1 )
227 {
228 for( k = 0; k < cn; k++ )
229 for( i = 0; i < tab_size; i += cn )
230 tab[i + k] = k + left;
231 }
232 else
233 {
234 j = dj = cn;
235 for( i = left - cn; i >= 0; i -= cn )
236 {
237 for( k = 0; k < cn; k++ )
238 tab[i + k] = j + k + left;
239 if( (unsigned)(j += dj) >= (unsigned)srcroi.width )
240 j -= 2*dj, dj = -dj;
241 }
242
243 j = srcroi.width - cn*2;
244 dj = -cn;
245 for( i = left; i < tab_size; i += cn )
246 {
247 for( k = 0; k < cn; k++ )
248 tab[i + k] = j + k + left;
249 if( (unsigned)(j += dj) >= (unsigned)srcroi.width )
250 j -= 2*dj, dj = -dj;
251 }
252 }
253
254 if( int_mode )
255 {
256 idst += top*dststep;
257 for( i = 0; i < srcroi.height; i++, isrc += srcstep, idst += dststep )
258 {
259 if( idst + left != isrc )
260 for( j = 0; j < srcroi.width; j++ )
261 idst[j + left] = isrc[j];
262 for( j = 0; j < left; j++ )
263 {
264 k = tab[j];
265 idst[j] = idst[k];
266 }
267 for( ; j < tab_size; j++ )
268 {
269 k = tab[j];
270 idst[j + srcroi.width] = idst[k];
271 }
272 }
273 isrc -= srcroi.height*srcstep;
274 idst -= (top - srcroi.height)*dststep;
275 }
276 else
277 {
278 dst += top*dststep;
279 for( i = 0; i < srcroi.height; i++, src += srcstep, dst += dststep )
280 {
281 if( dst + left != src )
282 for( j = 0; j < srcroi.width; j++ )
283 dst[j + left] = src[j];
284 for( j = 0; j < left; j++ )
285 {
286 k = tab[j];
287 dst[j] = dst[k];
288 }
289 for( ; j < tab_size; j++ )
290 {
291 k = tab[j];
292 dst[j + srcroi.width] = dst[k];
293 }
294 }
295 src -= srcroi.height*srcstep;
296 dst -= (top - srcroi.height)*dststep;
297 }
298
299 for( t = 0; t < 2; t++ )
300 {
301 int i1, i2, di;
302 if( t == 0 )
303 i1 = top-1, i2 = 0, di = -1, j = 1, dj = 1;
304 else
305 i1 = top+srcroi.height, i2=dstroi.height, di = 1, j = srcroi.height-2, dj = -1;
306
307 for( i = i1; i != i2; i += di )
308 {
309 if( int_mode )
310 {
311 const int* s = idst + i*dststep;
312 int* d = idst + (j+top)*dststep;
313 for( k = 0; k < dstroi.width; k++ )
314 d[k] = s[k];
315 }
316 else
317 {
318 const uchar* s = dst + i*dststep;
319 uchar* d = dst + (j+top)*dststep;
320 for( k = 0; k < dstroi.width; k++ )
321 d[k] = s[k];
322 }
323
324 if( (unsigned)(j += dj) >= (unsigned)srcroi.height )
325 j -= 2*dj, dj = -dj;
326 }
327 }
328
329 return CV_OK;
330 }
331
332
333 static CvStatus CV_STDCALL
icvCopyConstBorder_8u(const uchar * src,int srcstep,CvSize srcroi,uchar * dst,int dststep,CvSize dstroi,int top,int left,int cn,const uchar * value)334 icvCopyConstBorder_8u( const uchar* src, int srcstep, CvSize srcroi,
335 uchar* dst, int dststep, CvSize dstroi,
336 int top, int left, int cn, const uchar* value )
337 {
338 const int isz = (int)sizeof(int);
339 int i, j, k;
340 if( (cn | srcstep | dststep | (size_t)src | (size_t)dst | (size_t)value) % isz == 0 )
341 {
342 const int* isrc = (const int*)src;
343 int* idst = (int*)dst;
344 const int* ivalue = (const int*)value;
345 int v0 = ivalue[0];
346
347 cn /= isz;
348 srcstep /= isz;
349 dststep /= isz;
350
351 srcroi.width *= cn;
352 dstroi.width *= cn;
353 left *= cn;
354
355 for( j = 1; j < cn; j++ )
356 if( ivalue[j] != ivalue[0] )
357 break;
358
359 if( j == cn )
360 cn = 1;
361
362 if( dstroi.width <= 0 )
363 return CV_OK;
364
365 for( i = 0; i < dstroi.height; i++, idst += dststep )
366 {
367 if( i < top || i >= top + srcroi.height )
368 {
369 if( cn == 1 )
370 {
371 for( j = 0; j < dstroi.width; j++ )
372 idst[j] = v0;
373 }
374 else
375 {
376 for( j = 0; j < cn; j++ )
377 idst[j] = ivalue[j];
378 for( ; j < dstroi.width; j++ )
379 idst[j] = idst[j - cn];
380 }
381 continue;
382 }
383
384 if( cn == 1 )
385 {
386 for( j = 0; j < left; j++ )
387 idst[j] = v0;
388 for( j = srcroi.width + left; j < dstroi.width; j++ )
389 idst[j] = v0;
390 }
391 else
392 {
393 for( k = 0; k < cn; k++ )
394 {
395 for( j = 0; j < left; j += cn )
396 idst[j+k] = ivalue[k];
397 for( j = srcroi.width + left; j < dstroi.width; j += cn )
398 idst[j+k] = ivalue[k];
399 }
400 }
401
402 if( idst + left != isrc )
403 for( j = 0; j < srcroi.width; j++ )
404 idst[j + left] = isrc[j];
405 isrc += srcstep;
406 }
407 }
408 else
409 {
410 uchar v0 = value[0];
411
412 srcroi.width *= cn;
413 dstroi.width *= cn;
414 left *= cn;
415
416 for( j = 1; j < cn; j++ )
417 if( value[j] != value[0] )
418 break;
419
420 if( j == cn )
421 cn = 1;
422
423 if( dstroi.width <= 0 )
424 return CV_OK;
425
426 for( i = 0; i < dstroi.height; i++, dst += dststep )
427 {
428 if( i < top || i >= top + srcroi.height )
429 {
430 if( cn == 1 )
431 {
432 for( j = 0; j < dstroi.width; j++ )
433 dst[j] = v0;
434 }
435 else
436 {
437 for( j = 0; j < cn; j++ )
438 dst[j] = value[j];
439 for( ; j < dstroi.width; j++ )
440 dst[j] = dst[j - cn];
441 }
442 continue;
443 }
444
445 if( cn == 1 )
446 {
447 for( j = 0; j < left; j++ )
448 dst[j] = v0;
449 for( j = srcroi.width + left; j < dstroi.width; j++ )
450 dst[j] = v0;
451 }
452 else
453 {
454 for( k = 0; k < cn; k++ )
455 {
456 for( j = 0; j < left; j += cn )
457 dst[j+k] = value[k];
458 for( j = srcroi.width + left; j < dstroi.width; j += cn )
459 dst[j+k] = value[k];
460 }
461 }
462
463 if( dst + left != src )
464 for( j = 0; j < srcroi.width; j++ )
465 dst[j + left] = src[j];
466 src += srcstep;
467 }
468 }
469
470 return CV_OK;
471 }
472
473
474 CV_IMPL void
cvCopyMakeBorder(const CvArr * srcarr,CvArr * dstarr,CvPoint offset,int bordertype,CvScalar value)475 cvCopyMakeBorder( const CvArr* srcarr, CvArr* dstarr, CvPoint offset,
476 int bordertype, CvScalar value )
477 {
478 CV_FUNCNAME( "cvCopyMakeBorder" );
479
480 __BEGIN__;
481
482 CvMat srcstub, *src = (CvMat*)srcarr;
483 CvMat dststub, *dst = (CvMat*)dstarr;
484 CvSize srcsize, dstsize;
485 int srcstep, dststep;
486 int pix_size, type;
487
488 if( !CV_IS_MAT(src) )
489 CV_CALL( src = cvGetMat( src, &srcstub ));
490
491 if( !CV_IS_MAT(dst) )
492 CV_CALL( dst = cvGetMat( dst, &dststub ));
493
494 if( offset.x < 0 || offset.y < 0 )
495 CV_ERROR( CV_StsOutOfRange, "Offset (left/top border width) is negative" );
496
497 if( src->rows + offset.y > dst->rows || src->cols + offset.x > dst->cols )
498 CV_ERROR( CV_StsBadSize, "Source array is too big or destination array is too small" );
499
500 if( !CV_ARE_TYPES_EQ( src, dst ))
501 CV_ERROR( CV_StsUnmatchedFormats, "" );
502
503 type = CV_MAT_TYPE(src->type);
504 pix_size = CV_ELEM_SIZE(type);
505 srcsize = cvGetMatSize(src);
506 dstsize = cvGetMatSize(dst);
507 srcstep = src->step;
508 dststep = dst->step;
509 if( srcstep == 0 )
510 srcstep = CV_STUB_STEP;
511 if( dststep == 0 )
512 dststep = CV_STUB_STEP;
513
514 if( bordertype == IPL_BORDER_REPLICATE )
515 {
516 icvCopyReplicateBorder_8u( src->data.ptr, srcstep, srcsize,
517 dst->data.ptr, dststep, dstsize,
518 offset.y, offset.x, pix_size );
519 }
520 else if( bordertype == IPL_BORDER_REFLECT_101 )
521 {
522 icvCopyReflect101Border_8u( src->data.ptr, srcstep, srcsize,
523 dst->data.ptr, dststep, dstsize,
524 offset.y, offset.x, pix_size );
525 }
526 else if( bordertype == IPL_BORDER_CONSTANT )
527 {
528 double buf[4];
529 cvScalarToRawData( &value, buf, src->type, 0 );
530 icvCopyConstBorder_8u( src->data.ptr, srcstep, srcsize,
531 dst->data.ptr, dststep, dstsize,
532 offset.y, offset.x, pix_size, (uchar*)buf );
533 }
534 else
535 CV_ERROR( CV_StsBadFlag, "Unknown/unsupported border type" );
536
537 __END__;
538 }
539
540 /* End of file. */
541