Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Open Source Computer Vision Library https://opencv.org/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8987 Commits
6 Branches
128 Tags
3.0 GiB
 
 
 
 
 
 
Tag: Branch: Tree: e38ba1999b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e38ba1999b'
${ noResults }
opencv/modules/legacy/src/lines.cpp

479 lines
14 KiB
Raw Blame History

/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "precomp.hpp"
#if 0
CvStatus
icvFetchLine8uC3R( uchar * src, int src_step,
uchar * dst, int *dst_num, CvSize src_size, CvPoint start, CvPoint end )
{
int i;
int dx = end.x - start.x, dy = end.y - start.y;
int err;
if( !src || !dst || (src_size.width | src_size.height) < 0 ||
src_step < src_size.width * 3 ||
(unsigned) start.x >= (unsigned) src_size.width ||
(unsigned) start.y >= (unsigned) src_size.height ||
(unsigned) end.x >= (unsigned) src_size.width ||
(unsigned) end.y >= (unsigned) src_size.height )
return CV_BADFACTOR_ERR;
if( dx < 0 )
{
dx = -dx;
dy = -dy;
start.x = end.x;
start.y = end.y;
}
src += start.y * src_step + start.x * 3;
i = dy >> 31;
dy = (dy ^ i) - i;
src_step = (src_step ^ i) - i;
if( dx > dy )
{
if( dst_num )
{
if( *dst_num <= dx )
return CV_BADSIZE_ERR;
*dst_num = dx + 1;
}
err = dx;
dx += dx;
dy += dy;
for( i = dx; i >= 0; i -= 2, dst += 3 )
{
int mask = (err -= dy) < 0 ? -1 : 0;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
err += dx & mask;
src += (src_step & mask) + 3;
}
}
else
{
if( dst_num )
{
if( *dst_num <= dy )
return CV_BADSIZE_ERR;
*dst_num = dy + 1;
}
err = dy;
dx += dx;
dy += dy;
for( i = dy; i >= 0; i -= 2, dst += 3 )
{
int mask = (err -= dx) < 0 ? -1 : 0;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
err += dy & mask;
src += src_step + (mask & 3);
}
}
return CV_NO_ERR;
}
CvStatus
icvDrawLine8uC3R( uchar * src, int src_num,
uchar * dst, int dst_step, CvSize dst_size, CvPoint start, CvPoint end )
{
int i;
int dx = end.x - start.x, dy = end.y - start.y;
int err;
if( !src || !dst || (dst_size.width | dst_size.height) < 0 ||
dst_step < dst_size.width * 3 ||
(unsigned) start.x >= (unsigned) dst_size.width ||
(unsigned) start.y >= (unsigned) dst_size.height ||
(unsigned) end.x >= (unsigned) dst_size.width ||
(unsigned) end.y >= (unsigned) dst_size.height )
return CV_BADFACTOR_ERR;
if( dx < 0 )
{
dx = -dx;
dy = -dy;
start.x = end.x;
start.y = end.y;
}
dst += start.y * dst_step + start.x * 3;
i = dy >> 31;
dy = (dy ^ i) - i;
dst_step = (dst_step ^ i) - i;
if( dx > dy )
{
if( (unsigned) (src_num - 1) < (unsigned) dx )
return CV_BADSIZE_ERR;
err = dx;
dx += dx;
dy += dy;
for( i = dx; i >= 0; i -= 2, src += 3 )
{
int mask = (err -= dy) < 0 ? -1 : 0;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
err += dx & mask;
dst += (dst_step & mask) + 3;
}
}
else
{
if( (unsigned) (src_num - 1) < (unsigned) dy )
return CV_BADSIZE_ERR;
err = dy;
dx += dx;
dy += dy;
for( i = dy; i >= 0; i -= 2, src += 3 )
{
int mask = (err -= dx) < 0 ? -1 : 0;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
err += dy & mask;
dst += dst_step + (mask & 3);
}
}
return CV_NO_ERR;
}
#endif
/*======================================================================================*/
static CvStatus
icvPreWarpImage8uC3R( int numLines, /* number of scanlines */
uchar * src, /* source image */
int src_step, /* line step */
uchar * dst, /* dest buffers */
int *dst_nums, /* lens of buffer */
CvSize src_size, /* image size in pixels */
int *scanlines ) /* scanlines array */
{
int k;
CvPoint start;
CvPoint end;
int curr;
int curr_dst;
CvMat mat;
curr = 0;
curr_dst = 0;
cvInitMatHeader( &mat, src_size.height, src_size.width, CV_8UC3, src, src_step );
for( k = 0; k < numLines; k++ )
{
start.x = scanlines[curr++];
start.y = scanlines[curr++];
end.x = scanlines[curr++];
end.y = scanlines[curr++];
#ifdef _DEBUG
{
CvLineIterator iterator;
assert( cvInitLineIterator( &mat, start, end, &iterator, 8 ) == dst_nums[k] );
}
#endif
cvSampleLine( &mat, start, end, dst + curr_dst, 8 );
curr_dst += dst_nums[k] * 3;
}
return CV_NO_ERR;
}
/*======================================================================================*/
static CvStatus
icvPostWarpImage8uC3R( int numLines, /* number of scanlines */
uchar * src, /* source buffers */
int *src_nums, /* lens of buffers */
uchar * dst, /* dest image */
int dst_step, /* dest image step */
CvSize dst_size, /* dest image size */
int *scanlines ) /* scanline */
{
int i, k;
CvPoint start;
CvPoint end;
int curr;
int src_num;
int curr_src;
CvMat mat;
CvLineIterator iterator;
curr = 0;
curr_src = 0;
cvInitMatHeader( &mat, dst_size.height, dst_size.width, CV_8UC3, dst, dst_step );
for( k = 0; k < numLines; k++ )
{
start.x = scanlines[curr++];
start.y = scanlines[curr++];
end.x = scanlines[curr++];
end.y = scanlines[curr++];
src_num = src_nums[k];
if( cvInitLineIterator( &mat, start, end, &iterator, 8 ) != src_num )
{
assert(0);
return CV_NOTDEFINED_ERR;
}
for( i = 0; i < src_num; i++ )
{
memcpy( iterator.ptr, src + curr_src, 3 );
CV_NEXT_LINE_POINT( iterator );
curr_src += 3;
}
#if 0
err = icvDrawLine8uC3R( src + curr_src, /* sourse buffer */
src_num, /* len of buffer */
dst, /* dest image */
dst_step, /* dest image step */
dst_size, /* dest image size */
start, /* start point */
end ); /* end point */
curr_src += src_num * 3;
#endif
}
return CV_NO_ERR;
}
/*======================================================================================*/
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: icvDeleteMoire8uC3R
// Purpose:
// Function deletes moire - replaces black uncovered pixels with their neighboors.
// Context:
// Parameters:
// img - image data
// img_step - distance between lines in bytes
// img_size - width and height of the image in pixels
// Returns:
// CV_NO_ERR if all Ok or error code
// Notes:
//F*/
static CvStatus
icvDeleteMoire8u( uchar * img, int img_step, CvSize img_size, int cn )
{
int x, y;
uchar *src = img, *dst = img + img_step;
if( !img || img_size.width <= 0 || img_size.height <= 0 || img_step < img_size.width * 3 )
return CV_BADFACTOR_ERR;
img_size.width *= cn;
for( y = 1; y < img_size.height; y++, src = dst, dst += img_step )
{
switch( cn )
{
case 1:
for( x = 0; x < img_size.width; x++ )
{
if( dst[x] == 0 )
dst[x] = src[x];
}
break;
case 3:
for( x = 0; x < img_size.width; x += 3 )
{
if( dst[x] == 0 && dst[x + 1] == 0 && dst[x + 2] == 0 )
{
dst[x] = src[x];
dst[x + 1] = src[x + 1];
dst[x + 2] = src[x + 2];
}
}
break;
default:
assert(0);
break;
}
}
return CV_NO_ERR;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: cvDeleteMoire
// Purpose: The functions delete moire on the image after ViewMorphing
// Context:
// Parameters: img - image on which will delete moire
//
// Notes:
//F*/
CV_IMPL void
cvDeleteMoire( IplImage * img )
{
uchar *img_data = 0;
int img_step = 0;
CvSize img_size;
CV_FUNCNAME( "cvDeleteMoire" );
__BEGIN__;
cvGetImageRawData( img, &img_data, &img_step, &img_size );
if( img->nChannels != 1 && img->nChannels != 3 )
CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
if( img->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, "Channel depth of source image must be 8." );
CV_CALL( icvDeleteMoire8u( img_data, img_step, img_size, img->nChannels ));
__END__;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: cvPreWarpImage
// Purpose: The functions warp image for next stage of ViewMorphing
// Context:
// Parameters: img - initial image (in the beginning)
//
// Notes:
//F*/
CV_IMPL void
cvPreWarpImage( int numLines, /* number of scanlines */
IplImage * img, /* Source Image */
uchar * dst, /* dest buffers */
int *dst_nums, /* lens of buffer */
int *scanlines /* scanlines array */ )
{
uchar *img_data = 0;
int img_step = 0;
CvSize img_size;
CV_FUNCNAME( "cvPreWarpImage" );
__BEGIN__;
cvGetImageRawData( img, &img_data, &img_step, &img_size );
if( img->nChannels != 3 )
CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
if( img->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, "Channel depth of image must be 8." );
CV_CALL( icvPreWarpImage8uC3R( numLines, /* number of scanlines */
img_data, /* source image */
img_step, /* line step */
dst, /* dest buffers */
dst_nums, /* lens of buffer */
img_size, /* image size in pixels */
scanlines /* scanlines array */ ));
__END__;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: cvPostWarpImage
// Purpose: The functions postwarp the image after morphing
// Context:
// Parameters: img - initial image (in the beginning)
//
// Notes:
//F*/
CV_IMPL void
cvPostWarpImage( int numLines, /* number of scanlines */
uchar * src, /* source buffers */
int *src_nums, /* lens of buffers */
IplImage * img, /* dest image */
int *scanlines /* scanline */ )
{
uchar *img_data = 0;
int img_step = 0;
CvSize img_size;
CV_FUNCNAME( "cvPostWarpImage" );
__BEGIN__;
cvGetImageRawData( img, &img_data, &img_step, &img_size );
if( img->nChannels != 3 )
CV_ERROR( CV_BadNumChannels, "Source image must have 3 channel." );
if( img->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, "Channel depth of image must be 8." );
CV_CALL( icvPostWarpImage8uC3R( numLines, /* number of scanlines */
src, /* source buffers */
src_nums, /* lens of buffers */
img_data, /* dest image */
img_step, /* dest image step */
img_size, /* dest image size */
scanlines /* scanline */ ));
__END__;
}
/* End of file */