NV12 图像数据的插值时候旋转

最新推荐文章于 2022-10-01 20:13:34 发布
最新推荐文章于 2022-10-01 20:13:34 发布
阅读量665 收藏 2
点赞数
分类专栏： 图像处理 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_31872269/article/details/64921973
版权 
对外的接口有三个

1：对NV12或NV21 数据的插值和旋转，是对整张图操作
int NV12LinearAndRo(unsigned char * srcImage, unsigned char * destImage, int srcW, int srcH, int destW, int destH, int * afterW, int * afterH, int cammeraId, int angle)
2：修正1,速度可能会快一些
int NV12LinearAndRo_fix(unsigned char * srcImage, unsigned char * destImage, int srcW, int srcH, int destW, int destH, int * afterW, int * afterH, int cammeraId, int angle)
3：功能更加强大，对原始图抠图，对抠出来的图像进行插值和旋转
int NVCutLinearRo(unsigned char * srcImage, unsigned char * destImage, int srcW, int srcH, int x0, int y0, int x1, int y1, int destW, int destH, int * afterW, int * afterH, int cammeraId, int angle)

static int ChangeWH(int angle, int destW, int destH, int * afterW, int * afterH)
{


    if ((angle == 0 || angle == 180))
    {
        *afterW = destH;
        *afterH = destW;
    }
    else
    {
        *afterW = destW;
        *afterH = destH;
    }

    return 0;

}


static int PixelRoChannels(unsigned char * dest, int idx, int idy, int destW, int destH, int value, int cameraId, int angle, int channels, int channel)
{
    int width = destW;
    int height = destH;
    int theRealW = 0;

    int dx = 0;
    int dy = 0;
    int k = 0;

    // 前置摄像头
    if (0 == cameraId)
    {
        // 图像数据向右旋转 90 度
        if (0 == angle)
        {

            dx = height - 1 - idy;
            dy = idx;

            theRealW = height;

            dest[(dy * theRealW + dx) * channels + channel] = value;

        }
        // 图像方向不变
        else if (90 == angle)
        {
            dx = idx;
            dy = idy;

            theRealW = width;

            dest[(dy * theRealW + dx) * channels + channel] = value;
        }
        // 旋转180度
        else if (270 == angle)
        {
            dx = width - 1 - idx;
            dy = height - 1 - idy;

            theRealW = width;

            dest[(dy * theRealW + dx) * channels + channel] = value;


        }
        // 左旋90度
        else if (180 == angle)
        {
            dx = idy;
            dy = width - 1 - idx;

            theRealW = height;

            dest[(dy * theRealW + dx) * channels + channel] = value;
        }

    }
    else
    {
        // 左旋90度，左右镜像
        if (0 == angle)
        {
            dx = height - 1 - idy;
            dy = width - 1 - idx;

            theRealW = height;

            dest[(dy * theRealW + dx) * channels + channel] = value;

        }
        // 左右镜像
        else if (90 == angle)
        {
            dx = width - 1 - idx;
            dy = idy;

            theRealW = width;

            dest[(dy * theRealW + dx) * channels + channel] = value;
        }
        // // 上下镜像
        else if (270 == angle)
        {

            dx = idx;
            dy = height - 1 - idy;

            theRealW = width;

            dest[(dy * theRealW + dx) * channels + channel] = value;


        }
        else if (180 == angle)
        {
            // 右旋90 然后左右镜像

            dx = idy;
            dy = idx;

            theRealW = height;

            dest[(dy * theRealW + dx) * channels + channel] = value;

        }

    }
    return 0;
}

/*
参数说明

srcImage 输入数据的图像 为NV12 数据
destImage 输出的插值后的数据指针
srcW 输入图像的宽
srcH 输入图像的高

destW 插值后没有旋转的宽
destH 插值后没有旋转的高

afterW 插值后旋转后图像的宽
afterH 插值后旋转后图像的高

cammeraId 0 代表后置摄像头， 1 代表前置摄像头
angle 角度信息，手机的四个方向角度


*/



int NV12LinearAndRo(unsigned char * srcImage, unsigned char * destImage, int srcW, int srcH, int destW, int destH, int * afterW, int * afterH, int cammeraId, int angle)
{

    float timeX = 0.0f;
    float timeY = 0.0f;

    timeX = srcW * 1.0f / destW;
    timeY = srcH * 1.0f / destH;

    int i = 0;
    int j = 0;
    int k = 0;

    unsigned char * srcUV = srcImage + srcW * srcH;
    unsigned char * destUV = destImage + destW * destH;

    ChangeWH(angle, destW, destH, afterW, afterH);

    for (i = 0; i < destH; i++)
    {
        for (j = 0; j < destW; j++)
        {

            int srcIdX = 0;
            int srcIdY = 0;

            float srcfIdX = 0.0f;
            float srcfIdY = 0.0f;


            float weightX[2] = { 0.0f, 0.0f };
            float weightY[2] = { 0.0f, 0.0f };

            srcfIdX = j * timeX;
            srcfIdY = i * timeY;

            srcIdX = (int)(srcfIdX);
            srcIdY = (int)(srcfIdY);

            weightX[1] = srcfIdX - srcIdX;
            weightX[0] = 1.0f - weightX[1];

            weightY[1] = srcfIdY - srcIdY;
            weightY[0] = 1.0f - weightY[1];



            //destImage[(i * destW + j)] 
            int value = (srcImage[(srcIdY * srcW + srcIdX)] * weightX[0] + srcImage[(srcIdY * srcW + clamp_g(srcIdX + 1, 0, srcW - 1))] * weightX[1]) * weightY[0] +
                (srcImage[(clamp_g(srcIdY + 1, 0, srcH - 1) * srcW + srcIdX)] * weightX[0] + srcImage[(clamp_g(srcIdY + 1, 0, srcH - 1) * srcW + clamp_g(srcIdX + 1, 0, srcW - 1))] * weightX[1]) * weightY[1];


            //PixelRo(destImage, j, i, destW, destH, value, cammeraId, angle);
            PixelRoChannels(destImage, j, i, destW, destH, value, cammeraId, angle, 1, 0);
            if (0 == i % 2 && 0 == j % 2)
            {

                int srcVUW = srcW / 2;
                int srcVUH = srcH / 2;

                int destVUW = destW / 2;
                int destVUH = destH / 2;

                int destVUy = i / 2;
                int destVUx = j / 2;


                int UVsrcIdX = 0;
                int UVsrcIdY = 0;

                float UVsrcfIdX = 0.0f;
                float UVsrcfIdY = 0.0f;


                float UVweightX[2] = { 0.0f };
                float UVweightY[2] = { 0.0f };

                UVsrcfIdX = destVUx * timeX;
                UVsrcfIdY = destVUy * timeY;


                UVsrcIdX = (int)(UVsrcfIdX);
                UVsrcIdY = (int)(UVsrcfIdY);



                UVweightX[1] = UVsrcfIdX - UVsrcIdX;
                UVweightX[0] = 1.0f - UVweightX[1];

                UVweightY[1] = UVsrcfIdY - UVsrcIdY;
                UVweightY[0] = 1.0f - UVweightY[1];


                //destUV[(destVUy * destVUW + destVUx) * 2 + 0] =
                int value0 = (srcUV[(UVsrcIdY * srcVUW + UVsrcIdX) * 2 + 0] * weightX[0] + srcUV[(UVsrcIdY * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 0] * weightX[1]) * weightY[0] +
                    (srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + UVsrcIdX) * 2 + 0] * weightX[0] + srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 0] * weightX[1]) * weightY[1];

                //destUV[(destVUy * destVUW + destVUx) * 2 + 1] =
                int value1 = (srcUV[(UVsrcIdY * srcVUW + UVsrcIdX) * 2 + 1] * weightX[0] + srcUV[(UVsrcIdY * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 1] * weightX[1]) * weightY[0] +
                    (srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + UVsrcIdX) * 2 + 1] * weightX[0] + srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 1] * weightX[1]) * weightY[1];

                //destUV[(destVUy * destVUW + destVUx) * 2 + 0] = value0;

                //destUV[(destVUy * destVUW + destVUx) * 2 + 1] = value1;

                PixelRoChannels(destUV, destVUx, destVUy, destVUW, destVUH, value0, cammeraId, angle, 2, 0);

                PixelRoChannels(destUV, destVUx, destVUy, destVUW, destVUH, value1, cammeraId, angle, 2, 1);


            }

        }
    }

    return 0;
}


// 修正函数 修改了UV通道求权重的地方，之前UV权重是用的Y通道的，现在修正过来，另外把Y通道和UV通道的赋值
// 分开，提高速度，因为缓存对连续的空间访问会快

int NV12LinearAndRo_fix(unsigned char * srcImage, unsigned char * destImage, int srcW, int srcH, int destW, int destH, int * afterW, int * afterH, int cammeraId, int angle)
{

    float timeX = 0.0f;
    float timeY = 0.0f;

    timeX = srcW * 1.0f / destW;
    timeY = srcH * 1.0f / destH;

    int i = 0;
    int j = 0;
    int k = 0;

    unsigned char * srcUV = srcImage + srcW * srcH;
    unsigned char * destUV = destImage + destW * destH;

    ChangeWH(angle, destW, destH, afterW, afterH);

    for (i = 0; i < destH; i++)
    {
        for (j = 0; j < destW; j++)
        {

            int srcIdX = 0;
            int srcIdY = 0;

            float srcfIdX = 0.0f;
            float srcfIdY = 0.0f;


            float weightX[2] = { 0.0f, 0.0f };
            float weightY[2] = { 0.0f, 0.0f };

            srcfIdX = j * timeX;
            srcfIdY = i * timeY;

            srcIdX = (int)(srcfIdX);
            srcIdY = (int)(srcfIdY);

            weightX[1] = srcfIdX - srcIdX;
            weightX[0] = 1.0f - weightX[1];

            weightY[1] = srcfIdY - srcIdY;
            weightY[0] = 1.0f - weightY[1];


            int value = (srcImage[(srcIdY * srcW + srcIdX)] * weightX[0] + srcImage[(srcIdY * srcW + clamp_g(srcIdX + 1, 0, srcW - 1))] * weightX[1]) * weightY[0] +
                (srcImage[(clamp_g(srcIdY + 1, 0, srcH - 1) * srcW + srcIdX)] * weightX[0] + srcImage[(clamp_g(srcIdY + 1, 0, srcH - 1) * srcW + clamp_g(srcIdX + 1, 0, srcW - 1))] * weightX[1]) * weightY[1];

            PixelRoChannels(destImage, j, i, destW, destH, value, cammeraId, angle, 1, 0);


        }
    }

    for (i = 0; i < destH; i++)
    {
        for (j = 0; j < destW; j++)
        {

            int srcVUW = srcW / 2;
            int srcVUH = srcH / 2;

            int destVUW = destW / 2;
            int destVUH = destH / 2;

            int destVUy = i / 2;
            int destVUx = j / 2;


            int UVsrcIdX = 0;
            int UVsrcIdY = 0;

            float UVsrcfIdX = 0.0f;
            float UVsrcfIdY = 0.0f;


            float UVweightX[2] = { 0.0f };
            float UVweightY[2] = { 0.0f };

            UVsrcfIdX = destVUx * timeX;
            UVsrcfIdY = destVUy * timeY;


            UVsrcIdX = (int)(UVsrcfIdX);
            UVsrcIdY = (int)(UVsrcfIdY);



            UVweightX[1] = UVsrcfIdX - UVsrcIdX;
            UVweightX[0] = 1.0f - UVweightX[1];

            UVweightY[1] = UVsrcfIdY - UVsrcIdY;
            UVweightY[0] = 1.0f - UVweightY[1];


            int value0 = (srcUV[(UVsrcIdY * srcVUW + UVsrcIdX) * 2 + 0] * UVweightX[0] + srcUV[(UVsrcIdY * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 0] * UVweightX[1]) * UVweightY[0] +
                (srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + UVsrcIdX) * 2 + 0] * UVweightX[0] + srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 0] * UVweightX[1]) * UVweightY[1];

            int value1 = (srcUV[(UVsrcIdY * srcVUW + UVsrcIdX) * 2 + 1] * UVweightX[0] + srcUV[(UVsrcIdY * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 1] * UVweightX[1]) * UVweightY[0] +
                (srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + UVsrcIdX) * 2 + 1] * UVweightX[0] + srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 1] * UVweightX[1]) * UVweightY[1];


            PixelRoChannels(destUV, destVUx, destVUy, destVUW, destVUH, value0, cammeraId, angle, 2, 0);

            PixelRoChannels(destUV, destVUx, destVUy, destVUW, destVUH, value1, cammeraId, angle, 2, 1);


        }
    }

    return 0;
}



/*
作用： 从原始图像上抠图，然后插值为指定的宽高，然后再旋转
参数说明：
srcImage 原始输入图像数据 NV12或者NV21 （内存大小为srcW * srcH * 3 / 2 ）
destImage 输出的数据 NV12 或者NV21 (内存大小为（x1 - x0 + 1）（y1 - y0 + 1） * 3 / 2)
srcW srcImage 图像的宽
srcH srcImage 图像的高
x0 截取图像左上角的x值 （保证偶数， 因为NV12或者NV21 公用UV 通道）
y0 截取图像左上角的y值 （保证偶数， 因为NV12或者NV21 公用UV 通道）
x1 截取图像右下角的x值 （保证奇数， 保证（x1 - x0 + 1）输出的宽为偶数）
y1 截取图像右下角的y值 （保证奇数， 保证（y1 - x1 + 1）输出的宽为偶数）

destW 截取之后插值的宽 （保证偶数）
destH 截取之后插值的高 （保证偶数）

afterW 运行完之后输出的宽 = destW 或者 destH 和cammeraId 和 angle 有关
afterH 运行完之后输出的宽 = destW 或者 destH 和cammeraId 和 angle 有关

cammeraId 以手机为例子，0代表后置摄像头，1 代表前置摄像头
angle 0， 90， 180， 270相机的角度，0代表书评，90代表逆时针90度


*/

int NVCutLinearRo(unsigned char * srcImage, unsigned char * destImage, int srcW, int srcH, int x0, int y0, int x1, int y1, int destW, int destH, int * afterW, int * afterH, int cammeraId, int angle)
{



    float timeX = 0.0f;
    float timeY = 0.0f;
    int srcCutW = 0;
    int srcCutH = 0;

    srcCutW = x1 - x0 + 1;
    srcCutH = y1 - y0 + 1;


    timeX = srcCutW * 1.0f / destW;
    timeY = srcCutH * 1.0f / destH;

    int i = 0;
    int j = 0;
    int k = 0;

    unsigned char * srcUV = srcImage + srcW * srcH;
    unsigned char * destUV = destImage + destW * destH;

    ChangeWH(angle, destW, destH, afterW, afterH);

    for (i = 0; i < destH; i++)
    {
        for (j = 0; j < destW; j++)
        {

            int srcIdX = 0;
            int srcIdY = 0;

            float srcfIdX = 0.0f;
            float srcfIdY = 0.0f;


            float weightX[2] = { 0.0f, 0.0f };
            float weightY[2] = { 0.0f, 0.0f };

            srcfIdX = j * timeX + x0;
            srcfIdY = i * timeY + y0;

            srcIdX = (int)(srcfIdX);
            srcIdY = (int)(srcfIdY);

            weightX[1] = srcfIdX - srcIdX;
            weightX[0] = 1.0f - weightX[1];

            weightY[1] = srcfIdY - srcIdY;
            weightY[0] = 1.0f - weightY[1];



            //destImage[(i * destW + j)] 
            int value = (srcImage[(srcIdY * srcW + srcIdX)] * weightX[0] + srcImage[(srcIdY * srcW + clamp_g(srcIdX + 1, 0, srcW - 1))] * weightX[1]) * weightY[0] +
                (srcImage[(clamp_g(srcIdY + 1, 0, srcH - 1) * srcW + srcIdX)] * weightX[0] + srcImage[(clamp_g(srcIdY + 1, 0, srcH - 1) * srcW + clamp_g(srcIdX + 1, 0, srcW - 1))] * weightX[1]) * weightY[1];

            PixelRoChannels(destImage, j, i, destW, destH, value, cammeraId, angle, 1, 0);


        }
    }

    for (i = 0; i < destH; i++)
    {
        for (j = 0; j < destW; j++)
        {

            int srcVUW = srcW / 2;
            int srcVUH = srcH / 2;

            int destVUW = destW / 2;
            int destVUH = destH / 2;

            int destVUy = i / 2;
            int destVUx = j / 2;


            int UVsrcIdX = 0;
            int UVsrcIdY = 0;

            float UVsrcfIdX = 0.0f;
            float UVsrcfIdY = 0.0f;


            float UVweightX[2] = { 0.0f };
            float UVweightY[2] = { 0.0f };

            UVsrcfIdX = destVUx * timeX + x0 / 2;
            UVsrcfIdY = destVUy * timeY + y0 / 2;


            UVsrcIdX = (int)(UVsrcfIdX);
            UVsrcIdY = (int)(UVsrcfIdY);



            UVweightX[1] = UVsrcfIdX - UVsrcIdX;
            UVweightX[0] = 1.0f - UVweightX[1];

            UVweightY[1] = UVsrcfIdY - UVsrcIdY;
            UVweightY[0] = 1.0f - UVweightY[1];



            int value0 = (srcUV[(UVsrcIdY * srcVUW + UVsrcIdX) * 2 + 0] * UVweightX[0] + srcUV[(UVsrcIdY * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 0] * UVweightX[1]) * UVweightY[0] +
                (srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + UVsrcIdX) * 2 + 0] * UVweightX[0] + srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 0] * UVweightX[1]) * UVweightY[1];


            int value1 = (srcUV[(UVsrcIdY * srcVUW + UVsrcIdX) * 2 + 1] * UVweightX[0] + srcUV[(UVsrcIdY * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 1] * UVweightX[1]) * UVweightY[0] +
                (srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + UVsrcIdX) * 2 + 1] * UVweightX[0] + srcUV[(clamp_g(UVsrcIdY + 1, 0, srcVUH - 1) * srcVUW + clamp_g(UVsrcIdX + 1, 0, srcVUW - 1)) * 2 + 1] * UVweightX[1]) * UVweightY[1];



            PixelRoChannels(destUV, destVUx, destVUy, destVUW, destVUH, value0, cammeraId, angle, 2, 0);

            PixelRoChannels(destUV, destVUx, destVUy, destVUW, destVUH, value1, cammeraId, angle, 2, 1);


        }
    }

    return 0;

}
LIZhang2016
关注
专栏目录
双线性内插法进行图像旋转算法的C代码实现
tugouxp的专栏
03-20 2933
原图： 代码： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stddef.h> #include <stdint.h> #include <fcntl.h> #include <unistd.h> #include <assert.h> #include <sys/ioctl.h> #include
Android OpenGL开发实践 - GLSurfaceView对YUV格式数据的处理
lkl22的专栏
03-27 4520
一、创建OpenGL ES 环境 在清单中声明OpenGL ES 为了使您的应用程序能够使用OpenGL ES 2.0 API，您必须在清单中添加以下声明： <uses-feature android:glEsVersion="0x00020000" android:required="true" /> 构建GLSurfaceView对象 class MyGLSurfaceView(...
nv12旋转90度
04-23
本人取一帧数据保存成.yuv数据，同学运行时，自己创建android，将mainAct和res/mian_layout覆盖即可。.yuv数据一定存放在sdcard下（adb shell）,自己确定好路径，即可实现效果
NV12 图像数据的旋转
张利 的博客
03-22 1632
/ img 原始数据 destImg 目的数据 m_width 原始数据的宽，旋转后可能改变 m_height 原始数据的高 m_cammer 0 前置摄像头 1 后置摄像头 m_angle 角度看程序决定图像右旋还是左旋还有镜像/ static int imgRotationNew(unsigned char *img, unsigned char *destImg, int * m_width,
nv12 图像的旋转
beibei_hao_csdn的博客
04-17 1765
int nv12rote270(unsigned char * src, unsigned char * dst, int srcW, int srcH) { int wide = srcW; int high = srcH; unsigned char * srcUV = src + wide  * high; unsigned char * destUV = dst + wi
图像几何变换（缩放、旋转）中的插值算法
zyl910的专栏
11-25 4859
这是我在一些 数字图像与图形处理 方面的书上面看见的，书上说的比较零散，我稍微整理了一下 实践已证明，插值算法对于缩放比例较小的情况是完全可以接受的，令人信服的。一般的，缩小0.5倍以上或放大3.0倍以下，对任何图像都是可以接受的。 最邻近插值（近邻取样法）：　　最临近插值的的思想很简单。对于通过反向变换得到的的一个浮点坐标，对其进行简单的取整，得到一个整数型坐标，这个整数
视频流NV12旋转90度,保存成mp4格式的一种方案
sjy0118的博客
09-16 1171
说明：项目中使用usb网络摄像头，在横屏版本使用后台看视频正常，但是需要适配竖屏版本的，竖屏视频传到后台是横着的，需要旋转90度。由于设备是嵌入式，编译耗时，单独截取一帧数据，用android方式来做，效率很高。 具体实现步骤：将nv12转成nv21,nv21再旋转90度，但是有些算法nv12转成nv21不支持 核心代码如下： //调用，byteBuffer为nv12数据 byt...
NV21图像旋转、平移、缩放、画矩形的C++实现
03-22
总的来说，NV21图像的处理涉及对图像数据结构的深入理解以及对各种图像操作算法的掌握。通过提供的源代码，你可以学习到如何在C++环境中有效地处理这种格式的图像，这对于Android开发者来说是一项宝贵的技术。
NV21 旋转缩放转BGR
03-01
C++中处理这种格式的数据通常涉及到对图像进行旋转、缩放以及色彩空间转换，如从NV21转换到BGR（或RGB）。本篇文章将深入探讨这些关键知识点。 首先，NV21格式的图像数据存储方式为：每个像素都有一个Y分量，然后每...
定向响应网络：主动旋转卷积过程中，产生明确编码的位置和方向的特征图，用于深度学习图像表示和分类
然而，它们在处理显著的局部和全局图像旋转方面的能力仍然有限。在本文中，我们提出了主动旋转过滤器（ARF），积极旋转卷积过程中，并产生明确编码的位置和方向的特征图。ARF充当包含滤波器本身及其多个非物质化旋转...
nv12图像叠加水印
08-03
对应博文：https://blog.csdn.net/lyy901135/article/details/98232619
YUV（NV12 NV21等） RGB（16，24，32位） 原始数据（无压缩）的图片和视频查看工具
10-11
可以直接打开 YUV NV21 NV12 YUV420 YUV444 YUV422 RGB16 RGB24 RGB32 RGBA等格式的从内存中直接保存的原始无压缩图片
YUV数据 nv21转nv12 以及YUV数据顺时针旋转90度工具函数
weixin_43911199的博客
10-01 791
YUV４２０一共有四种，有时候数据之间需要转换，用到最多的就是ｎｖ２１转ｎｖ１２。编码时候相机获取到的数据需要顺时针旋转９０度，从而宽长变成长宽。
android nv21 nv12,android - 将NV21转换为NV12并旋转90度通过libyuv？ - 堆栈内存溢出
weixin_42363388的博客
05-28 959
我正在开发一个Android Camera应用程序。 当我处理框架时，遇到了一些麻烦。在相机的onPreviewFrame(字节[]数据，摄像头摄像头)功能，我设置数据的格式是NV21 fromat，由于NV21是支持所有的Android设备。当我使用MediaCodec编码帧时，KEY_COLOR_FORMAT为COLOR_FormatYUV420SemiPlanar( NV12 )。所以我需...
转：：图像几何变换（缩放、旋转）中的插值算法
为了理想而奋斗
03-13 3540
图像几何变换（缩放、旋转）中的插值算法转自：http://www.5inet.net/Develop/DevCraft/058199,TuXiangJiHeBianHuan(SuFang_XuanZhuai)ZhongDeChaZhiSuanFa.aspx最邻近插值（近邻取样法）：　　最临近插值的的思想很简单。对于通过反向变换得到的的一个浮点坐标，供7:PTjL5u;a9.{+hT
图像旋转+二线性插值算法
ubuntu_ai
12-21 920
long BilinearInterpolateD( const SwImage & pic,double fx,double fy ) { #define BILINEAR4_UNITRPOC(a,b,c,d) ((a<<22) +(b-a)*rx2048 + (c-a)*ry2048 + (a-b-c+d)*rxry ) long x = (long)fx; long y = (
YUV420(NV21或NV12)图像任意角度旋转的推导
轮子初级玩家
01-13 1450
一、坐标旋转: 假设我要沿着图像M的中心旋转角度b，那么需要先将图像M的中心移动到与坐标轴中心重合（否则将导致图像M沿坐标轴原点旋转）： 然后假设原坐标(x,y)距离坐标轴原点距离为r，与x轴夹角a度，需要绕原点旋转b度，那么可有如下推导： 设宽高分别为w,h 原坐标为: x = r * cos(a) y = r * sin(a) 新坐标为 x_new = r * cos(a+b) = r*cos(a)*cos(b) - r*sin(a)*sin(b) =(x-w/2)*cos(.
单片机C语言任意角度旋转图片,图片任意角度旋转（转）
weixin_31190113的博客
05-24 1245
/***@param imgSource 源图像*@param cx 旋转点相对于源图像坐上角横坐标*@param cy 旋转点相对于源图像坐上角纵坐标*@param theta 图像逆时针旋转的角度*@return 旋转后的图像*/public Image rotate(Image imgSource, int cx, int cy, double theta){if (Math.ab...
c语言图片绕中心旋转旋转,c语言图形,请高手修改,效果是一个三角形绕一点旋转一周...
weixin_34338504的博客
05-24 163
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#definePAI3.14159265voidfdw(floatm[][3]){unsignedcount;for(count=0;count<3;count++){m[count][0]=0;m[count][1]=0;m[count][2]=0;m[count][count]=1;}}voidm...
labview能否读取摄像头采集nv12的视频数据
最新发布
12-22
此外，LabVIEW还提供了丰富的视觉和图像处理函数库，使得用户可以很容易地在程序中实现对NV12格式视频数据的读取和处理。通过使用LabVIEW中的这些工具和函数，用户可以快速、高效地进行视频数据处理和分析，满足各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值