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