git.maemo.org Git - opencv/blob - cvaux/src/cvlines.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 #include "_cvaux.h"
  42
  43 #if 0
  44 CvStatus
  45 icvFetchLine8uC3R( uchar * src, int src_step,
  46                    uchar * dst, int *dst_num, CvSize src_size, CvPoint start, CvPoint end )
  47 {
  48     int i;
  49     int dx = end.x - start.x, dy = end.y - start.y;
  50     int err;
  51
  52     if( !src || !dst || (src_size.width | src_size.height) < 0 ||
  53         src_step < src_size.width * 3 ||
  54         (unsigned) start.x >= (unsigned) src_size.width ||
  55         (unsigned) start.y >= (unsigned) src_size.height ||
  56         (unsigned) end.x >= (unsigned) src_size.width ||
  57         (unsigned) end.y >= (unsigned) src_size.height )
  58         return CV_BADFACTOR_ERR;
  59
  60     if( dx < 0 )
  61     {
  62         dx = -dx;
  63         dy = -dy;
  64         start.x = end.x;
  65         start.y = end.y;
  66     }
  67
  68     src += start.y * src_step + start.x * 3;
  69
  70     i = dy >> 31;
  71     dy = (dy ^ i) - i;
  72     src_step = (src_step ^ i) - i;
  73
  74     if( dx > dy )
  75     {
  76         if( dst_num )
  77         {
  78             if( *dst_num <= dx )
  79                 return CV_BADSIZE_ERR;
  80             *dst_num = dx + 1;
  81         }
  82         err = dx;
  83         dx += dx;
  84         dy += dy;
  85         for( i = dx; i >= 0; i -= 2, dst += 3 )
  86         {
  87             int mask = (err -= dy) < 0 ? -1 : 0;
  88
  89             dst[0] = src[0];
  90             dst[1] = src[1];
  91             dst[2] = src[2];
  92
  93             err += dx & mask;
  94             src += (src_step & mask) + 3;
  95         }
  96     }
  97     else
  98     {
  99         if( dst_num )
 100         {
 101             if( *dst_num <= dy )
 102                 return CV_BADSIZE_ERR;
 103             *dst_num = dy + 1;
 104         }
 105         err = dy;
 106         dx += dx;
 107         dy += dy;
 108         for( i = dy; i >= 0; i -= 2, dst += 3 )
 109         {
 110             int mask = (err -= dx) < 0 ? -1 : 0;
 111
 112             dst[0] = src[0];
 113             dst[1] = src[1];
 114             dst[2] = src[2];
 115
 116             err += dy & mask;
 117             src += src_step + (mask & 3);
 118         }
 119     }
 120     return CV_NO_ERR;
 121 }
 122
 123 CvStatus
 124 icvDrawLine8uC3R( uchar * src, int src_num,
 125                   uchar * dst, int dst_step, CvSize dst_size, CvPoint start, CvPoint end )
 126 {
 127     int i;
 128     int dx = end.x - start.x, dy = end.y - start.y;
 129     int err;
 130
 131     if( !src || !dst || (dst_size.width | dst_size.height) < 0 ||
 132         dst_step < dst_size.width * 3 ||
 133         (unsigned) start.x >= (unsigned) dst_size.width ||
 134         (unsigned) start.y >= (unsigned) dst_size.height ||
 135         (unsigned) end.x >= (unsigned) dst_size.width ||
 136         (unsigned) end.y >= (unsigned) dst_size.height )
 137         return CV_BADFACTOR_ERR;
 138
 139     if( dx < 0 )
 140     {
 141         dx = -dx;
 142         dy = -dy;
 143         start.x = end.x;
 144         start.y = end.y;
 145     }
 146
 147     dst += start.y * dst_step + start.x * 3;
 148
 149     i = dy >> 31;
 150     dy = (dy ^ i) - i;
 151     dst_step = (dst_step ^ i) - i;
 152
 153     if( dx > dy )
 154     {
 155         if( (unsigned) (src_num - 1) < (unsigned) dx )
 156             return CV_BADSIZE_ERR;
 157         err = dx;
 158         dx += dx;
 159         dy += dy;
 160         for( i = dx; i >= 0; i -= 2, src += 3 )
 161         {
 162             int mask = (err -= dy) < 0 ? -1 : 0;
 163
 164             dst[0] = src[0];
 165             dst[1] = src[1];
 166             dst[2] = src[2];
 167             err += dx & mask;
 168             dst += (dst_step & mask) + 3;
 169         }
 170     }
 171     else
 172     {
 173         if( (unsigned) (src_num - 1) < (unsigned) dy )
 174             return CV_BADSIZE_ERR;
 175         err = dy;
 176         dx += dx;
 177         dy += dy;
 178         for( i = dy; i >= 0; i -= 2, src += 3 )
 179         {
 180             int mask = (err -= dx) < 0 ? -1 : 0;
 181
 182             dst[0] = src[0];
 183             dst[1] = src[1];
 184             dst[2] = src[2];
 185             err += dy & mask;
 186             dst += dst_step + (mask & 3);
 187         }
 188     }
 189     return CV_NO_ERR;
 190 }
 191 #endif
 192
 193 /*======================================================================================*/
 194
 195 static CvStatus
 196 icvPreWarpImage8uC3R( int numLines,     /* number of scanlines   */
 197                       uchar * src,      /* source image          */
 198                       int src_step,     /* line step         */
 199                       uchar * dst,      /* dest buffers          */
 200                       int *dst_nums,    /* lens of buffer        */
 201                       CvSize src_size,  /* image size in pixels */
 202                       int *scanlines )  /* scanlines array       */
 203 {
 204     int k;
 205     CvPoint start;
 206     CvPoint end;
 207     int curr;
 208     int curr_dst;
 209     CvMat mat;
 210
 211     curr = 0;
 212     curr_dst = 0;
 213
 214     cvInitMatHeader( &mat, src_size.height, src_size.width, CV_8UC3, src, src_step );
 215
 216     for( k = 0; k < numLines; k++ )
 217     {
 218         start.x = scanlines[curr++];
 219         start.y = scanlines[curr++];
 220
 221         end.x = scanlines[curr++];
 222         end.y = scanlines[curr++];
 223
 224 #ifdef _DEBUG
 225         {
 226         CvLineIterator iterator;
 227         assert( cvInitLineIterator( &mat, start, end, &iterator, 8 ) == dst_nums[k] );
 228         }
 229 #endif
 230         cvSampleLine( &mat, start, end, dst + curr_dst, 8 );
 231         curr_dst += dst_nums[k] * 3;
 232
 233     }
 234
 235     return CV_NO_ERR;
 236 }
 237
 238
 239 /*======================================================================================*/
 240
 241 static CvStatus
 242 icvPostWarpImage8uC3R( int numLines,    /* number of scanlines  */
 243                        uchar * src,     /* source buffers       */
 244                        int *src_nums,   /* lens of buffers      */
 245                        uchar * dst,     /* dest image           */
 246                        int dst_step,    /* dest image step      */
 247                        CvSize dst_size, /* dest image size      */
 248                        int *scanlines ) /* scanline             */
 249 {
 250     int i, k;
 251     CvPoint start;
 252     CvPoint end;
 253     int curr;
 254     int src_num;
 255     int curr_src;
 256     CvMat mat;
 257     CvLineIterator iterator;
 258
 259     curr = 0;
 260     curr_src = 0;
 261
 262     cvInitMatHeader( &mat, dst_size.height, dst_size.width, CV_8UC3, dst, dst_step );
 263
 264     for( k = 0; k < numLines; k++ )
 265     {
 266         start.x = scanlines[curr++];
 267         start.y = scanlines[curr++];
 268
 269         end.x = scanlines[curr++];
 270         end.y = scanlines[curr++];
 271
 272         src_num = src_nums[k];
 273
 274         if( cvInitLineIterator( &mat, start, end, &iterator, 8 ) != src_num )
 275         {
 276             assert(0);
 277             return CV_NOTDEFINED_ERR;
 278         }
 279
 280         for( i = 0; i < src_num; i++ )
 281         {
 282             memcpy( iterator.ptr, src + curr_src, 3 );
 283             CV_NEXT_LINE_POINT( iterator );
 284             curr_src += 3;
 285         }
 286
 287 #if 0
 288         err = icvDrawLine8uC3R( src + curr_src, /* sourse buffer    */
 289                                 src_num,        /* len of buffer    */
 290                                 dst,    /* dest image       */
 291                                 dst_step,       /* dest image step  */
 292                                 dst_size,       /* dest image size  */
 293                                 start,  /* start point      */
 294                                 end );  /* end point        */
 295         curr_src += src_num * 3;
 296 #endif
 297     }
 298
 299     return CV_NO_ERR;
 300
 301 }
 302
 303
 304 /*======================================================================================*/
 305
 306 /*F///////////////////////////////////////////////////////////////////////////////////////
 307 //    Name:    icvDeleteMoire8uC3R
 308 //    Purpose:
 309 //      Function deletes moire - replaces black uncovered pixels with their neighboors.
 310 //    Context:
 311 //    Parameters:
 312 //      img       - image data
 313 //      img_step  - distance between lines in bytes
 314 //      img_size  - width and height of the image in pixels
 315 //    Returns:
 316 //      CV_NO_ERR if all Ok or error code
 317 //    Notes:
 318 //F*/
 319 static CvStatus
 320 icvDeleteMoire8u( uchar * img, int img_step, CvSize img_size, int cn )
 321 {
 322     int x, y;
 323     uchar *src = img, *dst = img + img_step;
 324
 325     if( !img || img_size.width <= 0 || img_size.height <= 0 || img_step < img_size.width * 3 )
 326         return CV_BADFACTOR_ERR;
 327
 328     img_size.width *= cn;
 329
 330     for( y = 1; y < img_size.height; y++, src = dst, dst += img_step )
 331     {
 332         switch( cn )
 333         {
 334         case 1:
 335             for( x = 0; x < img_size.width; x++ )
 336             {
 337                 if( dst[x] == 0 )
 338                     dst[x] = src[x];
 339             }
 340             break;
 341         case 3:
 342             for( x = 0; x < img_size.width; x += 3 )
 343             {
 344                 if( dst[x] == 0 && dst[x + 1] == 0 && dst[x + 2] == 0 )
 345                 {
 346                     dst[x] = src[x];
 347                     dst[x + 1] = src[x + 1];
 348                     dst[x + 2] = src[x + 2];
 349                 }
 350             }
 351             break;
 352         default:
 353             assert(0);
 354             break;
 355         }
 356     }
 357
 358     return CV_NO_ERR;
 359 }
 360
 361
 362 /*F///////////////////////////////////////////////////////////////////////////////////////
 363 //    Name: cvDeleteMoire
 364 //    Purpose: The functions delete moire on the image after ViewMorphing
 365 //    Context:
 366 //    Parameters:  img        - image on which will delete moire
 367 //
 368 //    Notes:
 369 //F*/
 370 CV_IMPL void
 371 cvDeleteMoire( IplImage * img )
 372 {
 373     uchar *img_data = 0;
 374     int img_step = 0;
 375     CvSize img_size;
 376
 377     CV_FUNCNAME( "cvDeleteMoire" );
 378
 379     __BEGIN__;
 380
 381     cvGetImageRawData( img, &img_data, &img_step, &img_size );
 382
 383     if( img->nChannels != 1 && img->nChannels != 3 )
 384         CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
 385     if( img->depth != IPL_DEPTH_8U )
 386         CV_ERROR( CV_BadDepth, "Channel depth of source image must be 8." );
 387
 388     CV_CALL( icvDeleteMoire8u( img_data, img_step, img_size, img->nChannels ));
 389
 390     __CLEANUP__;
 391     __END__;
 392
 393 }
 394
 395
 396 /*F///////////////////////////////////////////////////////////////////////////////////////
 397 //    Name: cvPreWarpImage
 398 //    Purpose: The functions warp image for next stage of ViewMorphing
 399 //    Context:
 400 //    Parameters:  img        - initial image (in the beginning)
 401 //
 402 //    Notes:
 403 //F*/
 404 CV_IMPL void
 405 cvPreWarpImage( int numLines,   /* number of scanlines */
 406                 IplImage * img, /* Source Image       */
 407                 uchar * dst,    /* dest buffers       */
 408                 int *dst_nums,  /* lens of buffer     */
 409                 int *scanlines /* scanlines array    */  )
 410 {
 411     uchar *img_data = 0;
 412     int img_step = 0;
 413     CvSize img_size;
 414
 415     CV_FUNCNAME( "cvPreWarpImage" );
 416
 417     __BEGIN__;
 418
 419     cvGetImageRawData( img, &img_data, &img_step, &img_size );
 420
 421     if( img->nChannels != 3 )
 422         CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
 423     if( img->depth != IPL_DEPTH_8U )
 424         CV_ERROR( CV_BadDepth, "Channel depth of image must be 8." );
 425
 426     CV_CALL( icvPreWarpImage8uC3R( numLines,    /* number of scanlines  */
 427                                    img_data,    /* source image         */
 428                                    img_step,    /* line step            */
 429                                    dst, /* dest buffers         */
 430                                    dst_nums,    /* lens of buffer       */
 431                                    img_size,    /* image size in pixels */
 432                                    scanlines /* scanlines array      */  ));
 433
 434     __CLEANUP__;
 435     __END__;
 436
 437 }
 438
 439
 440 /*F///////////////////////////////////////////////////////////////////////////////////////
 441 //    Name: cvPostWarpImage
 442 //    Purpose: The functions postwarp the image after morphing
 443 //    Context:
 444 //    Parameters:  img        - initial image (in the beginning)
 445 //
 446 //    Notes:
 447 //F*/
 448 CV_IMPL void
 449 cvPostWarpImage( int numLines,  /* number of scanlines  */
 450                  uchar * src,   /* source buffers       */
 451                  int *src_nums, /* lens of buffers      */
 452                  IplImage * img,        /* dest image           */
 453                  int *scanlines /* scanline             */  )
 454 {
 455     uchar *img_data = 0;
 456     int img_step = 0;
 457     CvSize img_size;
 458
 459     CV_FUNCNAME( "cvPostWarpImage" );
 460
 461     __BEGIN__;
 462
 463     cvGetImageRawData( img, &img_data, &img_step, &img_size );
 464
 465     if( img->nChannels != 3 )
 466         CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
 467     if( img->depth != IPL_DEPTH_8U )
 468         CV_ERROR( CV_BadDepth, "Channel depth of image must be 8." );
 469
 470     CV_CALL( icvPostWarpImage8uC3R( numLines,   /* number of scanlines   */
 471                                     src,        /* source buffers       */
 472                                     src_nums,   /* lens of buffers      */
 473                                     img_data,   /* dest image           */
 474                                     img_step,   /* dest image step      */
 475                                     img_size,   /* dest image size      */
 476                                     scanlines /* scanline             */  ));
 477
 478     __CLEANUP__;
 479     __END__;
 480 }
 481
 482 /* End of file */
 483