git.maemo.org Git - opencv/blob - cv/src/cvutils.cpp

   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
  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
 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
 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
 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
 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. */