前置变换后置变换OpenCV源代码 转自https://github.com/kipr/opencv/blob/master/modules/legacy/src/lines.cpp

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