modules/legacy/src/lines.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 "precomp.hpp"
  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     __END__;
 391
 392 }
 393
 394
 395 /*F///////////////////////////////////////////////////////////////////////////////////////
 396 //    Name: cvPreWarpImage
 397 //    Purpose: The functions warp image for next stage of ViewMorphing
 398 //    Context:
 399 //    Parameters:  img        - initial image (in the beginning)
 400 //
 401 //    Notes:
 402 //F*/
 403 CV_IMPL void
 404 cvPreWarpImage( int numLines,   /* number of scanlines */
 405                 IplImage * img, /* Source Image       */
 406                 uchar * dst,    /* dest buffers       */
 407                 int *dst_nums,  /* lens of buffer     */
 408                 int *scanlines /* scanlines array    */  )
 409 {
 410     uchar *img_data = 0;
 411     int img_step = 0;
 412     CvSize img_size;
 413
 414     CV_FUNCNAME( "cvPreWarpImage" );
 415
 416     __BEGIN__;
 417
 418     cvGetImageRawData( img, &img_data, &img_step, &img_size );
 419
 420     if( img->nChannels != 3 )
 421         CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
 422     if( img->depth != IPL_DEPTH_8U )
 423         CV_ERROR( CV_BadDepth, "Channel depth of image must be 8." );
 424
 425     CV_CALL( icvPreWarpImage8uC3R( numLines,    /* number of scanlines  */
 426                                    img_data,    /* source image         */
 427                                    img_step,    /* line step            */
 428                                    dst, /* dest buffers         */
 429                                    dst_nums,    /* lens of buffer       */
 430                                    img_size,    /* image size in pixels */
 431                                    scanlines /* scanlines array      */  ));
 432
 433     __END__;
 434
 435 }
 436
 437
 438 /*F///////////////////////////////////////////////////////////////////////////////////////
 439 //    Name: cvPostWarpImage
 440 //    Purpose: The functions postwarp the image after morphing
 441 //    Context:
 442 //    Parameters:  img        - initial image (in the beginning)
 443 //
 444 //    Notes:
 445 //F*/
 446 CV_IMPL void
 447 cvPostWarpImage( int numLines,  /* number of scanlines  */
 448                  uchar * src,   /* source buffers       */
 449                  int *src_nums, /* lens of buffers      */
 450                  IplImage * img,        /* dest image           */
 451                  int *scanlines /* scanline             */  )
 452 {
 453     uchar *img_data = 0;
 454     int img_step = 0;
 455     CvSize img_size;
 456
 457     CV_FUNCNAME( "cvPostWarpImage" );
 458
 459     __BEGIN__;
 460
 461     cvGetImageRawData( img, &img_data, &img_step, &img_size );
 462
 463     if( img->nChannels != 3 )
 464         CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
 465     if( img->depth != IPL_DEPTH_8U )
 466         CV_ERROR( CV_BadDepth, "Channel depth of image must be 8." );
 467
 468     CV_CALL( icvPostWarpImage8uC3R( numLines,   /* number of scanlines   */
 469                                     src,        /* source buffers       */
 470                                     src_nums,   /* lens of buffers      */
 471                                     img_data,   /* dest image           */
 472                                     img_step,   /* dest image step      */
 473                                     img_size,   /* dest image size      */
 474                                     scanlines /* scanline             */  ));
 475
 476     __END__;
 477 }
 478
 479 /* End of file */