图片任意角度旋转 梯形变换 任意四边形变换

#include <opencv.hpp>
using namespace cv;
typedef int s32;
typedef long long s64;
typedef s32 cfixed;
typedef  unsigned char u8;

#define cfixed_from_int(i)		(((cfixed)(i)) << 16)
#define cfixed_from_float(x)	((cfixed)((x) * 65536.0f))
#define cfixed_from_double(d)	((cfixed)((d) * 65536.0))
#define cfixed_to_int(f)		((f) >> 16)
#define cfixed_to_float(x)		((float)((x) / 65536.0f))
#define cfixed_const_1			(cfixed_from_int(1))
#define cfixed_const_e			((cfixed)(1))
#define cfixed_const_1_m_e		(cfixed_const_1 - cfixed_const_e)
#define cfixed_const_half		(cfixed_const_1 >> 1)
#define cfixed_frac(f)			((f) & cfixed_const_1_m_e)
#define cfixed_floor(f)			((f) & (~cfixed_const_1_m_e))
#define cfixed_ceil(f)			(cfixed_floor((f) + 0xffff))
#define cfixed_mul(x, y)		((cfixed)((((s64)(x)) * (y)) >> 16))
#define cfixed_div(x, y)		((cfixed)((((s64)(x)) << 16) / (y)))
#define cfixed_const_max		((s64)0x7fffffff)
#define cfixed_const_min		(-((((s64)1) << 31)))

//定点数辅助
#define IPIXEL_EPSILON			((cfixed)(2))
#define IPIXEL_IS_SAME(a, b)	(ipixel_within_epsilon(a, b, IPIXEL_EPSILON))
#define IPIXEL_IS_ZERO(a)		(ipixel_within_epsilon(a, 0, IPIXEL_EPSILON))
#define IPIXEL_IS_ONE(a)		(IPIXEL_IS_SAME(a, cfixed_const_1))
#define IPIXEL_IS_INT(a)		(IPIXEL_IS_ZERO(cfixed_frac(a)))
#define IPIXEL_IS_UNIT(a)		(IPIXEL_IS_SAME(a, cfixed_const_1) || \
IPIXEL_IS_SAME(a, -cfixed_const_1) || \
IPIXEL_IS_ZERO(a))

enum
{
IPIXEL_FILTER_BILINEAR	= 0,	// 滤波模式：双线性过滤采样
IPIXEL_FILTER_NEAREST	= 1,	// 滤波模式：最近采样
};

// 点的定义
typedef struct
{
cfixed x;
cfixed y;
}ipixel_point_fixed_t;

// 矢量定义
typedef struct
{
cfixed vector[3];
}ipixel_vector_t;

// 矩阵定义
typedef struct
{
cfixed matrix[3][3];
}ipixel_transform_t;

// 直线定义
typedef struct
{
ipixel_point_fixed_t p1;
ipixel_point_fixed_t p2;
}ipixel_line_fixed_t;

// 像素点定义
typedef struct
{
u8 rgb[3];
}ipixel_pixel_t;

static inline s32 ipixel_within_epsilon(cfixed a, cfixed b, cfixed epsilon)
{
cfixed c = a - b;
if (c < 0) c = -c;
return c <= epsilon;
}

// 线段与y轴相交的x坐标，ceil为是否向上去整
static inline cfixed ipixel_line_fixed_x(const ipixel_line_fixed_t *l,
cfixed y, s32 ceil)
{
cfixed dx = l->p2.x - l->p1.x;
s64 ex = ((s64)(y - l->p1.y)) * dx;
cfixed dy = l->p2.y - l->p1.y;
if (ceil) ex += (dy - 1);
return l->p1.x + (cfixed)(ex / dy);
}

static inline s32 ipixel_line_span_bound(const ipixel_line_fixed_t *t, s32 y, s32 *x)
{
cfixed x1, x2, y1, y2;
s32 yt, yb;
yt = cfixed_to_int(min(t->p1.y , t->p2.y));
yb = cfixed_to_int(max(t->p1.y , t->p2.y));
if (y < yt || y >= yb) return -2;

y1 = cfixed_from_int(y);
y2 = cfixed_from_int(y) + cfixed_const_1_m_e;
x1 = cfixed_ceil(ipixel_line_fixed_x(t, y1, 0));
x2 = cfixed_ceil(ipixel_line_fixed_x(t, y2, 0));
*x = cfixed_to_int((x1 > x2)? x1 : x2);

return 0;
}

static inline s32 ipixel_lines_bound(ipixel_line_fixed_t *t, int n ,s32 y, s32 *lx, s32 *rx)
{
s32 xmin = 0x7fff, xmax = -0x7fff;
s32 x[2];

for (s32 i = 0 , j = 0; i < n;  i++)
{
if (ipixel_line_span_bound(&t[i], y, &x[j]) == 0)
{
j++;
}
}

if (j == 2)
{
*lx = min(x[0],x[1]);
*rx = max(x[0],x[1]);
return 0;
}

return -1;
}

s32 ipixel_span_fetch(const Mat *img, s32 offset, s32 line, s32 width, u8 *card, const ipixel_transform_t *t);

/* 绕任一点的旋转 变换矩阵(顺时针)
*
* 用下面的线性方程组来表示关系，求解方程组可以得到矩阵:
* |Xdst|    |  cos  sin   (1-cos)*center.x - sin*center.y| |Xsrc|
* |Ydst|    | -sin  cos   sin*center.x + (1-cos)*center.y| |Ysrc|
* |  1 |    |   0    0                 1                 | |  1 |
*/

s32 ibitmap_rotate2D(Mat *dst,Mat *src,float angle)
{
angle *= 3.1415926f/180;
cfixed  alpha = cfixed_from_float(cos(angle));
cfixed  beta  = cfixed_from_float(sin(angle));

ipixel_point_fixed_t center = {0};
center.x = cfixed_from_float(src->cols/2.0);
center.y = cfixed_from_float(src->rows/2.0);

cfixed one_sub_alpha = cfixed_const_1 - alpha;
s64 onesubalpha_mul_centerx = (s64)one_sub_alpha * center.x;
s64 onesubalpha_mul_centery = (s64)one_sub_alpha * center.y;
s64 beta_mul_centerx = (s64)beta * center.x;
s64 beta_mul_centery = (s64)beta * center.y;

ipixel_transform_t matrix = {0};
matrix.matrix[0][0] =  alpha;
matrix.matrix[0][1] =  beta;
matrix.matrix[0][2] = (onesubalpha_mul_centerx - beta_mul_centery)>>16;
matrix.matrix[1][0] =  -beta;
matrix.matrix[1][1] =  alpha;
matrix.matrix[1][2] = (onesubalpha_mul_centery + beta_mul_centerx)>>16;
matrix.matrix[2][0] =  0;
matrix.matrix[2][1] =  0;
matrix.matrix[2][2] =  cfixed_const_1;

ipixel_point_fixed_t srcQuad[4] = {0};
ipixel_point_fixed_t dstQuad[4] = {0};

srcQuad[0].x = 0;
srcQuad[0].y = 0;
srcQuad[1].x = 0;
srcQuad[1].y = cfixed_from_int(src->rows);
srcQuad[2].x = cfixed_from_int(src->cols);
srcQuad[2].y = cfixed_from_int(src->rows);
srcQuad[3].x = cfixed_from_int(src->cols);
srcQuad[3].y = 0;

cfixed minX = 0x7fffffff;
cfixed maxX = 0x80000000;
cfixed minY = 0x7fffffff;
cfixed maxY = 0x80000000;

cfixed offsetx = cfixed_from_float((dst->cols - src->cols)/2.0);
cfixed offsety = cfixed_from_float((dst->rows - src->rows)/2.0);

for (s32 i = 0; i < 4; i++)
{
dstQuad[i].x = (cfixed)(((s64)srcQuad[i].x * (s64)matrix.matrix[0][0] + (s64)srcQuad[i].y * (s64)matrix.matrix[0][1])>>16) + matrix.matrix[0][2] + offsetx;
dstQuad[i].y = (cfixed)(((s64)srcQuad[i].x * (s64)matrix.matrix[1][0] + (s64)srcQuad[i].y * (s64)matrix.matrix[1][1])>>16) + matrix.matrix[1][2] + offsety;
if(dstQuad[i].x < minX) minX = dstQuad[i].x;
if(dstQuad[i].x > maxX) maxX = dstQuad[i].x;
if(dstQuad[i].y < minY) minY = dstQuad[i].y;
if(dstQuad[i].y > maxY) maxY = dstQuad[i].y;
}

matrix.matrix[0][0] =  alpha;
matrix.matrix[0][1] =  - beta;
matrix.matrix[0][2] =  (onesubalpha_mul_centerx + beta_mul_centery - (s64)alpha*offsetx + (s64)beta*offsety)>>16;
matrix.matrix[1][0] =  beta;
matrix.matrix[1][1] =  alpha;
matrix.matrix[1][2] =  (onesubalpha_mul_centery - beta_mul_centerx - (s64)alpha*offsety - (s64)beta*offsetx)>>16;
matrix.matrix[2][0] =  0;
matrix.matrix[2][1] =  0;
matrix.matrix[2][2] =  cfixed_const_1;

//四根直线
ipixel_line_fixed_t lines[4] = {0};
for (s32 i = 0 ; i < 4 ;i++)
{
lines[i].p1 = dstQuad[i];
lines[i].p2 = dstQuad[(i+1)%4];
}

//生成扫描区域
s32 width  = cfixed_to_int(maxX - minX);
s32 height = cfixed_to_int(maxY - minY);
s32 starty = cfixed_to_int(minY);
s32 endx   = cfixed_to_int(maxX);

size_t BuffSize = dst->step;
u8 *card = (u8*)malloc(BuffSize);  //工作空间申请

// 主要绘制循环
for (s32 j = 0; j < height; j++)
{
s32 xl, xr, xw;
s32 line = j + starty;

// 取得该扫描的X轴左右对应坐标
if (ipixel_lines_bound(&lines[0],4,line, &xl, &xr) != 0)
continue;

if (xl < 0) xl = 0;
if (xr >= endx) xr = endx - 1;

xw = xr - xl;

memset(card,0,BuffSize);
ipixel_span_fetch(src, xl, line, xw, card, &matrix);
memcpy(dst->data + dst->step*line  + xl*dst->elemSize(), card, xw*dst->elemSize());
}

free(card);
return 0;
}

#define IMATRIX_SOLVE_WORKMEM(n, m) ((sizeof(s32) * n + sizeof(float) * (m * n + n * n)))

// solve X from AX=B, result is saved to X
// A(0-(n-1), 0-(n-1)), X(0-(n-1), 0-(m-1)), B(0-(n-1), 0-(m-1))
// A(i, j) = A[i * n + j], B(i, j) = B[i * m + j]
// returns zero for success, others for error.
s32 imatrix_solve_n_m(const float A[], const float B[], float X[], s32 n, s32 m)
{
// 求解矩阵所需要的临时内存大小

u8 *workmem = (u8*)malloc(IMATRIX_SOLVE_WORKMEM(n, m));
s32 *js, l, k, i, j, is, p, q;
float *a, *b, d, t;

// initialize
a = (float*)(workmem + sizeof(s32) * n);
b = (float*)(workmem + sizeof(s32) * n + sizeof(float) * n * n);

for (i = n * n - 1; i >= 0; i--)
a[i] = A[i];
for (i = m * n - 1; i >= 0; i--)
b[i] = B[i];

js = (s32*)workmem;
is = 0;
l = 1;

// solve main loop
for (k = 0; k <= n - 1; k++)
{
d = 0.0;
for (i = k; i <= n - 1; i++)
{
for (j = k; j <= n - 1; j++)
{
t = a[i * n + j];

if (t < 0)
t = -t;

if (t > d)
{
d = t;
js[k] = j;
is = i;
}
}
}

if (d + 1.0 == 1.0)
l = 0;
else
{
if (js[k] != k)
{
for (i = 0; i <= n - 1; i++)
{
p = i * n + k; q = i * n + js[k];
t = a[p]; a[p] = a[q]; a[q] = t;
}
}
if (is != k)
{
for (j = k; j <= n - 1; j++)
{
p = k * n + j;
q = is * n + j;
t = a[p];
a[p] = a[q];
a[q] = t;
}
for (j = 0; j <= m - 1; j++)
{
p = k * m + j;
q = is * m + j;
t = b[p];
b[p] = b[q];
b[q] = t;
}
}
}

// check if no result
if (l == 0)
{
return -1;
}

d = a[k * n + k];

for (j = k + 1; j <= n - 1; j++)
{
p = k * n + j;
a[p] = a[p] / d;
}

for (j = 0; j <= m - 1; j++)
{
p = k * m + j;
b[p] = b[p] / d;
}

for (j = k + 1; j <= n - 1; j++)
{
for (i = 0; i <= n - 1; i++)
{
p = i * n + j;
if (i != k)
{
a[p] = a[p] - a[i * n + k] * a[k * n + j];
}
}
}

for (j = 0; j <= m-1; j++)
{
for (i = 0; i <= n - 1; i++)
{
p = i * m + j;
if (i != k)
{
b[p] = b[p] - a[i * n + k] * b[k * m + j];
}
}
}
}

for (k = n - 1; k >= 0; k--)
{
if (js[k] != k)
{
for (j = 0; j <= m - 1; j++)
{
p = k * m + j; q = js[k] * m + j;
t = b[p]; b[p] = b[q]; b[q] = t;
}
}
}

for (i = m * n - 1; i >= 0; i--)
X[i] = b[i];

free(workmem);
return 0;
}

/* 计算透视投影的变换矩阵
*      c00*xi + c01*yi + c02
* ui = ---------------------
*      c20*xi + c21*yi + c22
*
*      c10*xi + c11*yi + c12
* vi = ---------------------
*      c20*xi + c21*yi + c22
*
* 用下面的线性方程组来表示关系，求解方程组可以得到矩阵:
* / x0 y0  1  0  0  0 -x0*u0 -y0*u0 \ /c00\ /u0\
* | x1 y1  1  0  0  0 -x1*u1 -y1*u1 | |c01| |u1|
* | x2 y2  1  0  0  0 -x2*u2 -y2*u2 | |c02| |u2|
* | x3 y3  1  0  0  0 -x3*u3 -y3*u3 |.|c10|=|u3|,
* |  0  0  0 x0 y0  1 -x0*v0 -y0*v0 | |c11| |v0|
* |  0  0  0 x1 y1  1 -x1*v1 -y1*v1 | |c12| |v1|
* |  0  0  0 x2 y2  1 -x2*v2 -y2*v2 | |c20| |v2|
* \  0  0  0 x3 y3  1 -x3*v3 -y3*v3 / \c21/ \v3/
*
* 其中:
*   cij - 变换剧照的元素, c22 = 1
*/
s32 itransform_perspective(float m[], const float src[], const float dst[])
{
float a[8][8], b[8], x[8];
s32 i;

for (i = 0; i < 4; i++)
{
a[i][0] = a[i + 4][3] = src[i * 2 + 0];
a[i][1] = a[i + 4][4] = src[i * 2 + 1];
a[i][2] = a[i + 4][5] = 1;
a[i][3] = a[i][4] = a[i][5] = 0;
a[i + 4][0] = a[i + 4][1] = a[i + 4][2] = 0;
a[i][6] = -src[i * 2 + 0] * dst[i * 2 + 0];
a[i][7] = -src[i * 2 + 1] * dst[i * 2 + 0];
a[i + 4][6] = -src[i * 2 + 0] * dst[i * 2 + 1];
a[i + 4][7] = -src[i * 2 + 1] * dst[i * 2 + 1];
b[i] = dst[i * 2 + 0];
b[i + 4] = dst[i * 2 + 1];
}

if (imatrix_solve_n_m(&a[0][0], b, x, 8, 1) != 0)
return -1;

for (i = 0; i < 8; i++) m[i] = x[i];
m[8] = 1.0;

return 0;
}

// 初始化透视矩阵
s32 ipixel_transform_init_perspective(ipixel_transform_t *matrix,
const  ipixel_point_fixed_t *src,
const  ipixel_point_fixed_t *dst)
{
float fsrc[8];
float fdst[8];
float fmat[9];
s32 i, j;
s64 n;

for (i = 0; i < 4; i++)
{
fsrc[i * 2 + 0] = cfixed_to_float(src[i].x);
fsrc[i * 2 + 1] = cfixed_to_float(src[i].y);
fdst[i * 2 + 0] = cfixed_to_float(dst[i].x);
fdst[i * 2 + 1] = cfixed_to_float(dst[i].y);
}

if (itransform_perspective(fmat, fsrc, fdst) != 0)
return -1;

for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
n = ((s64)( fmat[i * 3 + j] * 65536.0));  //注意
if (n < cfixed_const_min || n > cfixed_const_max)
{
return -2;
}
matrix->matrix[i][j] = (cfixed)n;
}
}
return 0;
}

s32 ibitmap_quadtransform(Mat *dst,Mat *src,ipixel_point_fixed_t* p )
{
//四根直线
ipixel_line_fixed_t lines[4] = {0};
for (s32 i = 0 ; i < 4 ;i++)
{
lines[i].p1 = p[i];
lines[i].p2 = p[(i+1)%4];
}

cfixed minX = 0x7fffffff;
cfixed maxX = 0x80000000;
cfixed minY = 0x7fffffff;
cfixed maxY = 0x80000000;
for (s32 i = 0; i < 4; i++)
{
if(p[i].x < minX) minX = p[i].x;
if(p[i].x > maxX) maxX = p[i].x;
if(p[i].y < minY) minY = p[i].y;
if(p[i].y > maxY) maxY = p[i].y;
}
//生成扫描区域
s32 width  = cfixed_to_int(maxX - minX);
s32 height = cfixed_to_int(maxY - minY);
s32 starty = cfixed_to_int(minY);
s32 endx   = cfixed_to_int(maxX);

size_t BuffSize = dst->step;
u8 *card = (u8*)malloc(BuffSize);  //工作空间申请

ipixel_point_fixed_t srcQuad[4];
srcQuad[0].x = 0;
srcQuad[0].y = 0;
srcQuad[1].x = 0;
srcQuad[1].y = cfixed_from_int(src->rows);
srcQuad[2].x = cfixed_from_int(src->cols);
srcQuad[2].y = cfixed_from_int(src->rows);
srcQuad[3].x = cfixed_from_int(src->cols);
srcQuad[3].y = 0;

//计算变换矩阵
ipixel_transform_t matrix = {0};

if (ipixel_transform_init_perspective(&matrix, p,&srcQuad[0]) != 0)
return -8;

// 主要绘制循环
for (s32 j = 0; j < height; j++)
{
s32 xl, xr, xw;
s32 line = j + starty;

// 取得该扫描的X轴左右对应坐标
if (ipixel_lines_bound(&lines[0],4,line, &xl, &xr) != 0)
continue;

if (xl < 0) xl = 0;
if (xr >= endx) xr = endx - 1;

xw = xr - xl;

memset(card,0,BuffSize);
ipixel_span_fetch(src, xl, line, xw, card, &matrix);
memcpy(dst->data + dst->step*line  + xl*dst->elemSize(), card, xw*dst->elemSize());
}

free(card);
return 0;
}

// 矩阵同点相乘: matrix * vector
s32 ipixel_transform_point(const ipixel_transform_t *t,ipixel_vector_t *vector)
{
ipixel_vector_t result = {0};
s64 partial;
s64 v;
s32 i, j;

for (j = 0; j < 3; j++)
{
v = 0;
for (i = 0; i < 3; i++)
{
partial = ((s64)t->matrix[j][i])*((s64)vector->vector[i]);
v += partial >> 16 ;
}
if (v > cfixed_const_max || v < cfixed_const_min)
return -1;
result.vector[j] = (cfixed)v;
}

*vector = result;

if (vector->vector[2] == 0)
return -2;

return 0;
}

void ibitmap_fetch_pixel(const Mat* img , ipixel_pixel_t* pr ,cfixed x, cfixed y)
{
s32 x0 = (x < 0)? 0 : (x >= img->cols)? (img->cols - 1) : x;
s32 y0 = (y < 0)? 0 : (y >= img->rows)? (img->rows - 1) : y;

u8* pdata = img->data + y0*img->step + x0 * img->elemSize();

pr->rgb[0] = pdata[0];
pr->rgb[1] = pdata[1];
pr->rgb[2] = pdata[2];
}

void ibitmap_fetch_pixel_bilinear(const Mat* img , ipixel_pixel_t* pr ,cfixed x, cfixed y)
{
cfixed x1 = x - cfixed_const_1 / 2;
cfixed y1 = y - cfixed_const_1 / 2;
cfixed distx = (x1 >> 8) & 0xff;
cfixed disty = (y1 >> 8) & 0xff;
x1 = cfixed_to_int(x1);
y1 = cfixed_to_int(y1);
s32 x2 = x1 + 1;
s32 y2 = y1 + 1;

ipixel_pixel_t c[2][2] = {0};
ibitmap_fetch_pixel(img ,&c[0][0],x1 ,y1 );
ibitmap_fetch_pixel(img ,&c[0][1],x2 ,y1 );
ibitmap_fetch_pixel(img ,&c[1][0],x1 ,y2 );
ibitmap_fetch_pixel(img ,&c[1][1],x2 ,y2 );

s32 distxy = distx * disty;
s32 distxiy = (distx << 8) - distxy;	/* distx * (256 - disty) */
s32 distixy = (disty << 8) - distxy;	/* disty * (256 - distx) */
s32 distixiy = 256 * 256 - (disty << 8) - (distx << 8) + distxy;		/* (256 - distx) * (256 - disty) */

for(s32 i = 0 ; i < 3 ; i++)
{
pr->rgb[i] = cfixed_to_int(c[0][0].rgb[i] * distixiy + c[0][1].rgb[i] * distxiy +c[1][0].rgb[i] * distixy + c[1][1].rgb[i] * distxy);
}
}

s32 ipixel_span_fetch(const Mat *img, s32 offset, s32 line, s32 width, u8 *card, const ipixel_transform_t *t )
{
ipixel_vector_t vec, step;
vec.vector[0] = cfixed_from_int(offset) + cfixed_const_half;
vec.vector[1] = cfixed_from_int(line) + cfixed_const_half;
vec.vector[2] = cfixed_const_1;

if (t != NULL)
{
if (ipixel_transform_point(t, &vec) != 0)
return -12;

step.vector[0] = t->matrix[0][0];
step.vector[1] = t->matrix[1][0];
step.vector[2] = t->matrix[2][0];
}
else
{
step.vector[0] = cfixed_const_1;
step.vector[1] = 0;
step.vector[2] = 0;
}

if (IPIXEL_IS_ZERO(step.vector[2]))
{
step.vector[2] = 0;

if (IPIXEL_IS_ONE(vec.vector[2]))
vec.vector[2] = cfixed_const_1;

if (vec.vector[2] != cfixed_const_1)
{
cfixed w = vec.vector[2];
vec.vector[0] = cfixed_div(vec.vector[0], w);
vec.vector[1] = cfixed_div(vec.vector[1], w);
vec.vector[2] = cfixed_const_1;
step.vector[0] = cfixed_div(step.vector[0], w);
step.vector[1] = cfixed_div(step.vector[1], w);
step.vector[2] = cfixed_div(step.vector[2], w);
}
}

cfixed u, v, w, du, dv, dw, x, y;
u = vec.vector[0];
v = vec.vector[1];
w = vec.vector[2];
du = step.vector[0];
dv = step.vector[1];
dw = step.vector[2];

u8* pdata = NULL;
ipixel_pixel_t pixel = {0};
s32 filter = IPIXEL_FILTER_BILINEAR;  //IPIXEL_FILTER_NEAREST
if (filter == IPIXEL_FILTER_BILINEAR)
{
if (w == cfixed_const_1 && dw == 0)
{
for (; width > 0; width--)
{
ibitmap_fetch_pixel_bilinear(img , &pixel ,u, v);
memcpy(card , &pixel , img->elemSize());
card += img->elemSize();
u += du;
v += dv;
w += dw;
}
}
else
{
for (; width > 0;  width--)
{
if (w != 0)
{
x = cfixed_div(u, w);
y = cfixed_div(v, w);
}
else
{
x = 0, y = 0;
}
ibitmap_fetch_pixel_bilinear(img , &pixel ,x, y );
memcpy(card , &pixel , img->elemSize());
card += img->elemSize();
u += du;
v += dv;
w += dw;
}
}
}
else//IPIXEL_FILTER_NEAREST
{
if (w == cfixed_const_1 && dw == 0)
{
for (; width > 0; width--)
{
ibitmap_fetch_pixel(img , &pixel ,u, v );
memcpy(card , &pixel , img->elemSize());
card += img->elemSize();
u += du;
v += dv;
w += dw;
}
}
else
{
for (; width > 0;  width--)
{
if (w != 0)
{
x = cfixed_div(u, w);
y = cfixed_div(v, w);
}
else
{
x = 0, y = 0;
}

s32 x0 = cfixed_to_int(x - cfixed_const_e);
s32 y0 = cfixed_to_int(y - cfixed_const_e);

ibitmap_fetch_pixel(img,&pixel,x0,y0);
memcpy(card , &pixel , 3);
card += img->elemSize();
u += du;
v += dv;
w += dw;
}
}
}
return 0;
}

typedef struct
{
s32 bottom;
s32 top;
s32 bottom_startx;
s32 bottom_endx;
s32 top_startx;
s32 top_endx;
}VTrapeParam_t;

void inline ibitmap_Linearfill(u8* dst , u8* src , cfixed s , cfixed d)
{
if (s > d)
{
cfixed step_x = cfixed_div(s,d);
s32 d_int = cfixed_to_int(d);
cfixed fixed_src = 0;
for (s32 i = 0; i < d_int ; i++)
{
memcpy(dst , src + 3*cfixed_to_int(fixed_src) , 3 );
fixed_src += step_x;
dst += 3;
}
}
else
{
cfixed step_x = cfixed_div(d,s);
s32 s_int = cfixed_to_int(s);
s32 size = 3*cfixed_to_int(cfixed_ceil(step_x));
cfixed fixed_dst = 0;

for (s32 i = 0; i < s_int ; i++)
{
memcpy(dst +  3 * cfixed_to_int(fixed_dst), src  , size);
fixed_dst += step_x;
src += 3;
}

}

}
void ibitmap_HTrapetransform( Mat *dst,Mat *src,VTrapeParam_t *thiz)
{
s32 bottom         = thiz->bottom;
s32 top			   = thiz->top;
s32 bottom_startx  = thiz->bottom_startx;
s32 bottom_endx    = thiz->bottom_endx;
s32 top_startx     = thiz->top_startx;
s32 top_endx       = thiz->top_endx;

u8* pSrcData = src->data;
u8* pDstData = dst->data;
u8* pSrc = src->data;
u8* pDst = dst->data;

cfixed starty_dst = cfixed_from_int(top);
cfixed starty_src = cfixed_from_int(0);
cfixed endy_dst   = cfixed_from_int(bottom);
cfixed endy_src   = cfixed_from_int(src->rows);
cfixed y_dst      = starty_dst;
cfixed y_src      = starty_src;
cfixed startx_dst = cfixed_from_int(top_startx) ;
cfixed endx_dst   = cfixed_from_int(top_endx) ;
cfixed endx_src   = cfixed_from_int(src->cols);

cfixed src_dy     = cfixed_div(endy_src - starty_src,endy_dst - starty_dst);
cfixed dst_dx1    = cfixed_div(cfixed_from_int(bottom_startx - top_startx),cfixed_from_int(bottom - top));
cfixed dst_dx2    = cfixed_div(cfixed_from_int(bottom_endx - top_endx),cfixed_from_int(bottom - top));

while(y_dst < endy_dst && y_src < endy_src)
{
cfixed x_dst = startx_dst;
cfixed x_src = 0;
cfixed dx_src =  cfixed_div(endx_src ,endx_dst - startx_dst);

pDst = pDstData + cfixed_to_int(y_dst)*dst->step + cfixed_to_int(startx_dst)*3;
pSrc = pSrcData + cfixed_to_int(y_src)*src->step ;

ibitmap_Linearfill(pDst , pSrc  , endx_src , endx_dst - startx_dst);

startx_dst += dst_dx1;
endx_dst   += dst_dx2;
y_dst += cfixed_const_1;
y_src += src_dy ;
}
}

s32 main()
{
Mat src = imread("res_fish.bmp");
imshow("Src" , src);

//水平梯形变换
Mat HTrapedst = Mat::zeros(600,800, CV_8UC3);    //创建目标图像
VTrapeParam_t tParam = {0};
tParam.bottom = 500;
tParam.top = 100;
tParam.top_startx = 200;
tParam.top_endx = 350;
tParam.bottom_startx = 10;
tParam.bottom_endx = 600;
ibitmap_HTrapetransform(&HTrapedst , &src , &tParam);
imshow("HTrapedst" , HTrapedst);

//任意四边形变换
Mat Quaddst = Mat::zeros(600,800, CV_8UC3);    //创建目标图像
ipixel_point_fixed_t dstQuad[4] = {0};
dstQuad[0].x = cfixed_from_int(10);
dstQuad[0].y = cfixed_from_int(70);
dstQuad[1].x = cfixed_from_int(200);
dstQuad[1].y = cfixed_from_int(230);
dstQuad[2].x = cfixed_from_int(250);
dstQuad[2].y = cfixed_from_int(100);
dstQuad[3].x = cfixed_from_int(130);
dstQuad[3].y = cfixed_from_int(20);
ibitmap_quadtransform(&Quaddst, &src,&dstQuad[0]);
imshow("Quaddst" , Quaddst);

s32 dst_Side_length = sqrt((float)src.cols*src.cols+(float)src.rows*src.rows)+1;
s32 angle = 0;
while (1)
{
++angle %= 360;
Mat Rotatedst = Mat::zeros(dst_Side_length,dst_Side_length, CV_8UC3);    //创建目标图像
ibitmap_rotate2D(&Rotatedst,&src,angle);
imshow("Dstimage", Rotatedst);
waitKey(40);
}
}