480 lines
14 KiB
C++
480 lines
14 KiB
C++
/*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 */
|