i-mode图像描绘的仿射变换的C++实现

最新推荐文章于 2023-11-19 06:00:00 发布
最新推荐文章于 2023-11-19 06:00:00 发布
阅读量761 收藏
点赞数
文章标签： c++ vector matrix function insert 算法

转自：http://zeze0556.tk/2010/01/15/i-mode图像描绘的仿射变换的C++实现

 

       曾经做项目的时候，用到了i-mode仿射变换的函数，对其算法寻找花费了不少时间，都没有找到最相像的。后来花费了一个周末，根据api提供的公式，重新复习下矩阵的计算，终于写了一个基本上完全一样效果的。看来，还是老老实实一些比较好写。
       <!--more-->
       <pre cpp="brush:cpp">
       #define EPSILON_E5 (int)(((int64)(1E-5))* (1<<FIX_POINT))
       int fabs( int a )
{
    if( a < 0)
        return -a;
    return a;
}
///

void Mat_Add_3X3(MATRIX3X3_PTR ma,
                 MATRIX3X3_PTR mb,
                 MATRIX3X3_PTR msum)
{
    // this function adds two 3x3 matrices together and
    // and stores the result

    for (int row=0; row<3; row++)
    {
        for (int col=0; col<3; col++)
        {
            // insert resulting row,col element
            msum->M[row][col] = ma->M[row][col] + mb->M[row][col];
        } // end for col

    } // end for row

} // end Mat_Add_3X3



void Mat_Mul_VECTOR3D_3X3(VECTOR3D_PTR  va,
                          MATRIX3X3_PTR mb,
                          VECTOR3D_PTR  vprod)
{
    // this function multiplies a VECTOR3D against a
    // 3x3 matrix - ma*mb and stores the result in mprod

    for (int col=0; col < 3; col++)
    {
        // compute dot product from row of ma
        // and column of mb
        int sum = 0; // used to hold result

        for (int row=0; row<3; row++)
        {
            // add in next product pair
            sum+=(va->M[row]*mb->M[col][row]/*>>FIX_POINT*/);
        } // end for index

        // insert resulting col element
        vprod->M[col] = sum;

    } // end for col

} // end Mat_Mul_VECTOR3D_3X3



void Mat_Init_3X3(MATRIX3X3_PTR ma,
                  int m00, int m01, int m02,
                  int m10, int m11, int m12,
                  int m20, int m21, int m22)
{
    // this function fills a 3x3 matrix with the sent data in row major form

    ma->M[0][0] = m00; ma->M[0][1] = m01; ma->M[0][2] = m02;
    ma->M[1][0] = m10; ma->M[1][1] = m11; ma->M[1][2] = m12;
    ma->M[2][0] = m20; ma->M[2][1] = m21; ma->M[2][2] = m22;

} // end Mat_Init_3X3

/

int Mat_Inverse_3X3(MATRIX3X3_PTR m, MATRIX3X3_PTR mi)
{
    // this function computes the inverse of a 3x3

    // first compute the determinate to see if there is
    // an inverse
    int det = ((int64)m->M[0][0]*(((int64)m->M[1][1]*m->M[2][2]>>FIX_POINT) - ((int64)m->M[2][1]*m->M[1][2]>>FIX_POINT))>>FIX_POINT) -
        ((int64)m->M[0][1]*(((int64)m->M[1][0]*m->M[2][2]>>FIX_POINT) - ((int64)m->M[2][0]*m->M[1][2]>>FIX_POINT))>>FIX_POINT) +
        ((int64)m->M[0][2]*(((int64)m->M[1][0]*m->M[2][1]>>FIX_POINT) - ((int64)m->M[2][0]*m->M[1][1]>>FIX_POINT))>>FIX_POINT);

    if (fabs(det) <= EPSILON_E5)
        return(0);

    // compute inverse to save divides
    int det_inv = ((1<<FIX_POINT)*(1<<FIX_POINT)/det);//<<FIX_POINT;

    // compute inverse using m-1 = adjoint(m)/det(m)
    mi->M[0][0] =  ((int64)det_inv*(((int64)m->M[1][1]*m->M[2][2]>>FIX_POINT) - ((int64)m->M[2][1]*m->M[1][2]>>FIX_POINT)))>>FIX_POINT;
    mi->M[1][0] = -((int64)det_inv*(((int64)m->M[1][0]*m->M[2][2]>>FIX_POINT) - ((int64)m->M[2][0]*m->M[1][2]>>FIX_POINT)))>>FIX_POINT;
    mi->M[2][0] =  (int64)det_inv*(((int64)m->M[1][0]*m->M[2][1]>>FIX_POINT) - ((int64)m->M[2][0]*m->M[1][1]>>FIX_POINT))>>FIX_POINT;

    mi->M[0][1] = -((int64)det_inv*(((int64)m->M[0][1]*m->M[2][2]>>FIX_POINT) - ((int64)m->M[2][1]*m->M[0][2]>>FIX_POINT)))>>FIX_POINT;
    mi->M[1][1] =  (int64)det_inv*(((int64)m->M[0][0]*m->M[2][2]>>FIX_POINT) - ((int64)m->M[2][0]*m->M[0][2]>>FIX_POINT))>>FIX_POINT;
    mi->M[2][1] = -((int64)det_inv*(((int64)m->M[0][0]*m->M[2][1]>>FIX_POINT) - ((int64)m->M[2][0]*m->M[0][1]>>FIX_POINT)))>>FIX_POINT;

    mi->M[0][2] =  (int64)det_inv*(((int64)m->M[0][1]*m->M[1][2]>>FIX_POINT) - ((int64)m->M[1][1]*m->M[0][2]>>FIX_POINT))>>FIX_POINT;
    mi->M[1][2] = -((int64)det_inv*(((int64)m->M[0][0]*m->M[1][2]>>FIX_POINT) - ((int64)m->M[1][0]*m->M[0][2]>>FIX_POINT)))>>FIX_POINT;
    mi->M[2][2] =  (int64)det_inv*(((int64)m->M[0][0]*m->M[1][1]>>FIX_POINT) - ((int64)m->M[1][0]*m->M[0][1]>>FIX_POINT))>>FIX_POINT;

    // return success
    return(1);

} // end Mat_Inverse_3X3

/



/

int Mat_Det_3X3(MATRIX3X3_PTR m)
{
    // computes the determinate of a 3x3 matrix using co-factor
    // expansion

    return((m->M[0][0]*((m->M[1][1]*m->M[2][2]>>FIX_POINT) - (m->M[2][1]*m->M[1][2]>>FIX_POINT))>>FIX_POINT) -
        (m->M[0][1]*((m->M[1][0]*m->M[2][2]>>FIX_POINT) - (m->M[2][0]*m->M[1][2]>>FIX_POINT))>>FIX_POINT) +
        (m->M[0][2]*((m->M[1][0]*m->M[2][1]>>FIX_POINT) - (m->M[2][0]*m->M[1][1]>>FIX_POINT))>>FIX_POINT) );

} // end Mat_Det_3X3
</pre>
        上面其实是要用到的算法，我记得是从《游戏编程大师》中摘抄的吧，中间为了计算正确，有一个最小值的判断，不然，可能会发生除0错误(<strong>1/det</strong>)。
        <pre class="brush:cpp">
        void drawImage(Image *img, int *buf, int ax, int ay, int aw, int ah)
{
    if( img == 0 )
        return;

    MATRIX3X3 Morg;
    MATRIX3X3 Mdes;
    Mat_Init_3X3( &Morg, buf[0], buf[1], buf[2] + (transX<<FIX_POINT), buf[3], buf[4], buf[5] + (transY<<FIX_POINT), 0,0, (1<<FIX_POINT) );
    Mat_Inverse_3X3(&Morg, &Mdes);
    VECTOR3D org_left_top;
    org_left_top.M[0] = 0;
    org_left_top.M[1] = 0;
    org_left_top.M[2] = 1;
    VECTOR3D org_left_bottom;
    org_left_bottom.M[0] = 0;
    org_left_bottom.M[1] = (ah);
    org_left_bottom.M[2] = 1;
    VECTOR3D org_right_top;
    org_right_top.M[0] = aw;
    org_right_top.M[1] = 0;
    org_right_top.M[2] = 1;
    VECTOR3D org_right_bottom;
    org_right_bottom.M[0] = aw;
    org_right_bottom.M[1] = ah;
    org_right_bottom.M[2] = 1;
    VECTOR3D des_left_top, des_left_bottom, des_right_top, des_right_bottom;
    Mat_Mul_VECTOR3D_3X3( &org_left_top, &Morg, &des_left_top);
    Mat_Mul_VECTOR3D_3X3( &org_left_bottom, &Morg, &des_left_bottom);
    Mat_Mul_VECTOR3D_3X3( &org_right_top, &Morg, &des_right_top);
    Mat_Mul_VECTOR3D_3X3( &org_right_bottom, &Morg, &des_right_bottom);
    int minx = ((int)(min(min(des_left_top.M[0], des_right_top.M[0]), min(des_left_bottom.M[0], des_right_bottom.M[0])))>>FIX_POINT);
    int miny = ((int)(min(min(des_left_top.M[1], des_right_top.M[1]), min(des_left_bottom.M[1], des_right_bottom.M[1])))>>FIX_POINT);
    int maxx = ((int)(max(max(des_left_top.M[0], des_right_top.M[0]), max(des_left_bottom.M[0], des_right_bottom.M[0])))>>FIX_POINT);
    int maxy = ((int)(max(max(des_left_top.M[1], des_right_top.M[1]), max(des_left_bottom.M[1], des_right_bottom.M[1])))>>FIX_POINT);
   
    if(minx >=  clip[0] + clip[2] || miny >= clip[1] + clip[3] || maxx <= clip[0] || maxy <= clip[1] )
        return;
    if( minx < clip[0] )
        minx = clip[0];
    if( maxx > clip[0] + clip[2] )
        maxx = clip[0] + clip[2];
    if( miny < clip[1] )
        miny = clip[1];
    if(maxy > clip[1] + clip[3] )
        maxy = clip[1] + clip[3];
    IBitmap *pback = IDISPLAY_GetDestination(m_pDisplay);
    IDIB* pDib = NULL;
    IBITMAP_QueryInterface( pback, AEECLSID_DIB, (void**)&pDib);
    IBITMAP_Release(pback);
    int* tablex_x = (int*)static_tablex_x;
    int* tablex_y = (int*)static_tablex_y;
    int* tabley_x = (int*)static_tabley_x;
    int* tabley_y = (int*)static_tabley_y;
for( int j = minx; j < maxx; j++)
{
    tablex_x[j-minx] = (j*Mdes.M[0][0]+Mdes.M[0][2])>>FIX_POINT;
}
for( int j = minx; j < maxx; j++)
{
    tablex_y[j-minx] = (j*Mdes.M[1][0]+Mdes.M[1][2])>>FIX_POINT;
}
for( int j = miny ; j < maxy; j++)
{
    tabley_x[j-miny] = (j*Mdes.M[0][1])>>FIX_POINT;
}
for( int j = miny; j < maxy; j++)
{
    tabley_y[j-miny] = (j*Mdes.M[1][1])>>FIX_POINT;
}
switch (img->m_pIDIB->nDepth) {
        case 16:
            {
                unsigned short *pdes = (unsigned short*)((unsigned char*)(pDib->pBmp) + pDib->nPitch * miny + (minx << 1));
                unsigned short *psrc = (unsigned short*)((unsigned char*)(img->m_pIDIB->pBmp) + img->m_pIDIB->nPitch *(ay)+ ((ax) << 1));
                int desstep = (pDib->nPitch >> 1) - (maxx - minx);
                int stepsrc = (img->m_pIDIB->nPitch>>1);
                int *ptablex_x = tablex_x;
                int *ptabley_x = tabley_x;
                int *ptablex_y = tablex_y;
                int *ptabley_y = tabley_y;
                for( int i = miny; i < maxy; i++, pdes += desstep, ptabley_x++, ptabley_y++, ptablex_x = tablex_x, ptablex_y = tablex_y )
                    for( int j = minx; j < maxx; j++, pdes++, ptablex_x++, ptablex_y++ )
                    {
                        int x = (*ptablex_x+*ptabley_x);
                        int y = (*ptablex_y+*ptabley_y);;
                        if( x < 0 || y < 0 || x >= aw || y >= ah )
                            continue;
                        unsigned short *ptsrc = psrc + y * stepsrc + x;
                        if( *ptsrc != img->m_pIDIB->ncTransparent )
                            *pdes = *ptsrc;

                    }
            }

            break;
    }
    IDIB_Release( pDib );
return;
}
        </pre>
        基本上已经完全优化了，值得注意的是，我是根据公式反过来计算的，即扫描要填充的区域，计算在原图中的位置，如果在原图上，则填充，如果不在原图上，则跳过。这样做的好处就是防止由于误差引起的漏点。旋转也可以采用类似的方法，改天有时间的话，把代码找到放出来。上述函数的使用办法，请参考相关的i-mode的代码。

zhangze
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于OpenCV与C++实现仿射变换，包括旋转，平移，缩放，偏移、组合变换
05-12
基于OpenCV与C++实现仿射变换，包括旋转，平移，缩放，偏移、组合变换
纯C++仿射变换实现
long00000kid的博客
10-16 3322
目录纯C++仿射变换实现前言原理代码实现结果验证 纯C++仿射变换实现 最近需要使用仿射变换进行一些应用，但又不想用到OpenCV和Halcon之类的库进行，就自己写了一个计算和实现函数，大概记录一下这个过程。 基本概念参考：图像变换的基本模型 前言 想要实现的效果，知道坐标系A的3个坐标，和对应坐标系B的3个坐标，得到变换关系，实现输入任意坐标系A的坐标(Xa, Ya)，可以计算得出坐标系B对应的坐标(Xb, Yb)。 原理 通过找资料知道公式如下： 即 x’ = a1*x + a2*y + tx y
C++ opencv 仿射变换详解
qxqsunshine的博客
03-23 3719
1、C++仿射变换中主要涉及到2个函数：getAffineTransform() 和warpAffine() 2、粗略的理解：getAffineTransform()是用来求得仿射变换矩阵的；而warpAffine()是用来对原图像进行仿射变换的，从而得到目标图像。 3、详解getAffineTransform函数。 函数作用：用于生成仿射变换矩阵 （1）一个任意的仿射变换都可以表示为：乘以一个矩阵（线性变换），加上一个向量（平移） （2）仿射变换可以用来表示的操作有：旋转（线性变换），平移（向量
图像的仿射变换原理及c++实现（旋转，平移，缩放，偏移，组合变换）
小武的博客
02-25 1万+
github地址：https://github.com/2209520576/Image-Processing-Algorithm 一.写在前面 几何空间变换是图像处理中的最基础的算法，主要包括图像的旋转，平移，缩放，偏移，组合变换等等，在冈萨雷斯的数字图像处理第三版的第二章就做了相关介绍，最常用的空间坐标变换之一就是仿射变换。虽然仿射变换很基础，但作用还是很大的，例如在车牌识别的预处理...
仿射变换的简单实现
weixin_47679436的博客
06-18 179
密码学
【C++】【Opencv】cv::warpAffine()仿射变换函数详解，实现平移、缩放和旋转等功能
最新发布
不定时分享，互相学习，共同进步
11-19 3982
仿射变换是一种二维变换，它可以将一个二维图形映射到另一个二维图形上，保持了图形的“形状”和“大小”不变，但可能会改变图形的方向和位置。仿射变换可以用一个线性变换矩阵来表示，该矩阵包含了六个参数，可以进行平移、缩放、旋转等操作。通过原理、函数和示例进行解析，帮助大家理解和使用。
F60#-Emgucv实现仿射变换.zip
09-02
VS2008下用C#实现Emgucv实现仿射变换代码例程,用于图像处理。
图像仿射变换 图像平移 python实现
12-22
写文章不易，如果您觉得此文对您有所帮助，请帮忙点赞、评论、收藏，感谢您！ 一. 仿射变换介绍：  请参考：图解图像仿射变换... python实现仿射变换——图像平移 import cv2 import numpy as np # 图像仿射变换->图
插值前置的仿射变换FPGA实现方法-论文
05-18
插值前置的仿射变换FPGA实现方法
基于仿射变换模型的图像跟踪系统的实现
04-16
文中设计研制了一种新型的基于仿射变换模型的实时图像跟踪系统。本跟踪系统已经通过实践检验，能够稳定的、准确的、快速的跟踪目标。并且系统有很大的升级潜力，除了能够满足仿射变换跟踪的要求之外，还能适用于其他...
仿射变换C++.rar
11-01
使用C++实现人脸对齐，默认112*96像素，也可以自己修改，输入参数为五个特征点。
OpenCV C++图像处理之仿射变换与透视变换
qq_44174360的博客
09-14 396
仿射变换是一种线性变换，它将一个二维或三维空间中的对象（如点、图像、图形等）映射到另一个空间中，保持了一些基本的几何性质，如直线的平行性和点的共线性。仿射变换通常由矩阵乘法和向量加法组成，其一般形式如下：其中，是映射矩阵。
【图像处理OpenCV(C++版)】——3.1几何变换之仿射变换
cqy阳的博客
12-30 2141
【图像处理OpenCV(C++版)】——3.1几何变换之仿射变换
【CUDA】C++实现warpaffine仿射变换及其逆变换
种一棵树最好的时间是十年前，其次是现在
01-04 1325
此时的输入图片为d，待求i，遍历待求i的每一像素，根据i至d的映射关系找出i（即前向计算出矩阵的i2d）；在调用compute函数后，输入i及d的尺寸，自动得到仿射变换矩阵i2d及d2i。这个例子中i尺寸为Size(550, 676),d的尺寸为(640,640)
opencv图像处理：图形的缩放和仿射变换（C++）
xiaosuqi1778的博客
10-12 2150
本篇文章主要从两方面来讲opencv中图像几何变换中有关缩放、旋转的原理和使用方法。其中重采样只讲最邻近插值法和双线性插值法，仿射变换具体函数实现不予列出。
OpenCV4（C++）—— 仿射变换、透射变换和极坐标变换
qq_43199575的博客
10-09 1067
但是还有一点：上图的红色框和蓝色框看起来中心点是一样的，因为红色框位于蓝色框中心位置。（1）getRotationMatrix2D()是为了得到一个仿射变换矩阵，然后通过 cv::warpAffine 函数应用到图像上进行旋转操作（如果我们已知图像旋转矩阵，可以自己生成旋转矩阵而不调用该函数）。（(2)前面说到，仿射变换矩阵是一个2×3的形式，而它的第三列就是平移向量b0，b1。根据矩阵相乘的规则，其中线性变换矩阵A为2×2的矩阵，平移向量B为2×1的向量，两者结合就是一个2×3的变换矩阵。
【C++ OpenCV】图像变换：连接、尺寸、翻转、旋转、仿射变换
dagengen12138的博客
06-15 1611
​​​int main()Mat img = imread("E://学习//OPEN-CV学习//lena.png");cout
图像几何变换之仿射变换原理及实现
热门推荐
Eating Lee
03-19 1万+
今天学习了仿射变换，将一张图片放置到另一张图片，感觉十分有趣，所以写了这篇博客，与大家一起分享一下！ 一、仿射变换 1.什么是仿射变换 2.alpha通道 3.仿射变换的求解 二、仿射变换的实现 1.主函数 2.主要函数的介绍 一、仿射变换 1.什么是仿射变换 （1）放射变换的定义 仿射变换是将一个平面的点映射到另一个平面内的二维投影。仿射变换保持了二维图形的“平直性”，即原...
已知图片的坐标,用c语言实现下列图像的变换,实现新的坐标,c语言数字图像处理（三）：仿射变换...
weixin_42107374的博客
05-17 242
仿射变换及坐标变换公式几何变换改进图像中像素间的空间关系。这些变换通常称为橡皮模变换，因为它们可看成是在一块橡皮模上印刷一幅图像，然后根据预定的一组规则拉伸该薄膜。在数字图像处理中，几何变换由两个基本操作组成：(1)坐标的空间变换(2)灰度内插，即对变换后的像素赋灰度值坐标变换公式(x,y) = T{(v, w)}其中，(v, w)是原图像中像素的坐标，(x, y)是变换后图像中像素的坐标。最常用...
c++实现对输入图像进行仿射变换的功能
06-02
可以使用OpenCV库来实现对输入图像进行仿射变换。具体步骤如下： 1. 导入OpenCV库：`#include <opencv2/opencv.hpp>` 2. 读取输入图像：`cv::Mat src = cv::imread("input.jpg");` 3. 定义仿射变换矩阵：`cv::Mat...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值