要C++的

好的，这是一个使用C++实现的带参数WARP_INVERSE_MAP的warpAffine函数，并使用SSE2指令集加速的示例代码：

#include <iostream>
#include <opencv2/opencv.hpp>
#include <emmintrin.h>

using namespace std;
using namespace cv;

void warpAffine_sse2(const Mat& src, Mat& dst, const Mat& M)
{
    int h = src.rows;
    int w = src.cols;
    dst.create(h, w, src.type());

    // 计算变换矩阵的逆矩阵
    Mat M_inv;
    invertAffineTransform(M, M_inv);

    // 使用SSE2指令集进行加速
    __m128i zero = _mm_setzero_si128();
    for (int y = 0; y < h; y++)
    {
        for (int x = 0; x < w; x += 4)
        {
            float fx[4], fy[4];
            __m128i ix, iy;
            __m128i i0, i1, i2, i3;
            __m128i val0, val1, val2, val3;
            __m128 dx, dy;
            __m128i irow0, irow1;
            __m128 frow0, frow1;

            // 计算变换后的像素坐标
            for (int k = 0; k < 4; k++)
            {
                int x0 = x + k;
                int y0 = y;
                fx[k] = M_inv.at<float>(0, 0) * x0 + M_inv.at<float>(0, 1) * y0 + M_inv.at<float>(0, 2);
                fy[k] = M_inv.at<float>(1, 0) * x0 + M_inv.at<float>(1, 1) * y0 + M_inv.at<float>(1, 2);
            }

            // 判断像素坐标是否在图像范围内
            ix = _mm_cvtps_epi32(_mm_load_ps(fx));
            iy = _mm_cvtps_epi32(_mm_load_ps(fy));
            i0 = _mm_cmplt_epi32(ix, zero);
            i1 = _mm_cmplt_epi32(iy, zero);
            i2 = _mm_cmpgt_epi32(ix, _mm_set1_epi32(w - 2));
            i3 = _mm_cmpgt_epi32(iy, _mm_set1_epi32(h - 2));
            if (_mm_movemask_epi8(_mm_or_si128(_mm_or_si128(i0, i1), _mm_or_si128(i2, i3))) != 0)
                continue;

            // 双线性插值
            dx = _mm_sub_ps(_mm_load_ps(fx), _mm_cvtepi32_ps(ix));
            dy = _mm_sub_ps(_mm_load_ps(fy), _mm_cvtepi32_ps(iy));
            irow0 = _mm_mul_epu32(_mm_add_epi32(_mm_mul_epu32(_mm_sub_epi32(_mm_set1_epi32(1), _mm_castps_si128(dy)), ix), _mm_mul_epu32(_mm_castps_si128(dy), _mm_add_epi32(ix, _mm_set1_epi32(1)))), _mm_set1_epi32(w * src.elemSize()));
            irow1 = _mm_add_epi32(irow0, _mm_set1_epi32(w * src.elemSize()));
            frow0 = _mm_sub_ps(_mm_set1_ps(1), dx);
            frow1 = dx;
            val0 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(src.data + iy[0] * src.step + irow0[0])), zero);
            val1 = _mm_unpackhi_epi8(_mm_loadl_epi64((const __m128i*)(src.data + iy[0] * src.step + irow0[0])), zero);
            val2 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(src.data + iy[0] * src.step + irow1[0])), zero);
            val3 = _mm_unpackhi_epi8(_mm_loadl_epi64((const __m128i*)(src.data + iy[0] * src.step + irow1[0])), zero);
            val0 = _mm_mullo_epi16(val0, _mm_castps_si128(frow0));
            val1 = _mm_mullo_epi16(val1, _mm_castps_si128(frow0));
            val2 = _mm_mullo_epi16(val2, _mm_castps_si128(frow1));
            val3 = _mm_mullo_epi16(val3, _mm_castps_si128(frow1));
            val0 = _mm_add_epi16(val0, val2);
            val1 = _mm_add_epi16(val1, val3);
            val0 = _mm_srli_epi16(_mm_add_epi16(val0, _mm_set1_epi16(1)), 1);
            val1 = _mm_srli_epi16(_mm_add_epi16(val1, _mm_set1_epi16(1)), 1);
            _mm_storeu_si128((__m128i*)(dst.data + y * dst.step + x * dst.elemSize()), _mm_packus_epi16(val0, val1));
        }
    }
}

int main()
{
    Mat src = imread("test.jpg");
    Mat dst1, dst2;
    Mat M = (Mat_<float>(2, 3) << 1, 0, 100, 0, 1, 50);

    // 使用OpenCV自带的函数进行变换
    warpAffine(src, dst1, M, src.size(), WARP_INVERSE_MAP);

    // 使用SSE2指令集加速的函数进行变换
    warpAffine_sse2(src, dst2, M);

    // 比较两个结果是否相同
    cout << "diff: " << countNonZero(dst1 != dst2) << endl;

    return 0;
}

在这个示例代码中，我们首先定义了一个warpAffine_sse2函数，用于进行变换。在函数内部，我们使用了SSE2指令集来加速双线性插值的计算。具体来说，我们使用了_mm_cvtps_epi32将浮点数转换为整数，_mm_cmplt_epi32和_mm_cmpgt_epi32进行了边界判断，_mm_unpacklo_epi8和_mm_unpackhi_epi8进行了像素值的拆分和扩展，_mm_mullo_epi16进行了乘法运算，_mm_add_epi16进行了加法运算，_mm_srli_epi16进行了右移运算，_mm_storeu_si128进行了内存写操作，等等。

最后，我们可以运行这个程序，测试两个函数的性能和正确性。