rgba/rgb 转bmp文件

最新推荐文章于 2024-05-11 21:23:20 发布
最新推荐文章于 2024-05-11 21:23:20 发布
阅读量925 收藏 1
点赞数
文章标签： p2p 蓝桥杯 gnu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GC286339554/article/details/121818445
版权

#include <stdio.h>  
#include <stdlib.h>  

typedef struct
{
    //unsigned short    bfType;  
    unsigned long    bfSize;
    unsigned short    bfReserved1;
    unsigned short    bfReserved2;
    unsigned long    bfOffBits;
} ClBitMapFileHeader;

typedef struct
{
    unsigned long  biSize;
    long   biWidth;
    long   biHeight;
    unsigned short   biPlanes;
    unsigned short   biBitCount;
    unsigned long  biCompression;
    unsigned long  biSizeImage;
    long   biXPelsPerMeter;
    long   biYPelsPerMeter;
    unsigned long   biClrUsed;
    unsigned long   biClrImportant;
} ClBitMapInfoHeader;

typedef struct
{
    unsigned char rgbBlue; //该颜色的蓝色分量  
    unsigned char rgbGreen; //该颜色的绿色分量  
    unsigned char rgbRed; //该颜色的红色分量  
    unsigned char rgbReserved; //保留值  
} ClRgbQuad;

typedef struct
{
    int width;
    int height;
    int channels;
    unsigned char* imageData;
}ClImage;

ClImage* clLoadImage(char* path);
bool clSaveImage(char* path, ClImage* bmpImg);


ClImage* clLoadImage(char* path)
{
    ClImage* bmpImg;
    FILE* pFile;
    unsigned short fileType;
    ClBitMapFileHeader bmpFileHeader;
    ClBitMapInfoHeader bmpInfoHeader;
    int channels = 1;
    int width = 0;
    int height = 0;
    int step = 0;
    int offset = 0;
    unsigned char pixVal;
    ClRgbQuad* quad;
    int i, j, k;

    bmpImg = (ClImage*)malloc(sizeof(ClImage));
    pFile = fopen(path, "rb+");
    if (!pFile)
    {
        free(bmpImg);
        return NULL;
    }

    fread(&fileType, sizeof(unsigned short), 1, pFile); 
    if (fileType == 0x4D42) //string "BM"
    {
        //printf("bmp file! \n");  

        fread(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);
        /*printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");
        printf("bmp文件头信息：\n");
        printf("文件大小：%d \n", bmpFileHeader.bfSize);
        printf("保留字：%d \n", bmpFileHeader.bfReserved1);
        printf("保留字：%d \n", bmpFileHeader.bfReserved2);
        printf("位图数据偏移字节数：%d \n", bmpFileHeader.bfOffBits);*/

        fread(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);
        /*printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");
        printf("bmp文件信息头\n");
        printf("结构体长度：%d \n", bmpInfoHeader.biSize);
        printf("位图宽度：%d \n", bmpInfoHeader.biWidth);
        printf("位图高度：%d \n", bmpInfoHeader.biHeight);
        printf("位图平面数：%d \n", bmpInfoHeader.biPlanes);
        printf("颜色位数：%d \n", bmpInfoHeader.biBitCount);
        printf("压缩方式：%d \n", bmpInfoHeader.biCompression);
        printf("实际位图数据占用的字节数：%d \n", bmpInfoHeader.biSizeImage);
        printf("X方向分辨率：%d \n", bmpInfoHeader.biXPelsPerMeter);
        printf("Y方向分辨率：%d \n", bmpInfoHeader.biYPelsPerMeter);
        printf("使用的颜色数：%d \n", bmpInfoHeader.biClrUsed);
        printf("重要颜色数：%d \n", bmpInfoHeader.biClrImportant);
        printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");*/

        if (bmpInfoHeader.biBitCount == 8)
        {
            //printf("该文件有调色板，即该位图为非真彩色\n\n");  
            channels = 1;
            width = bmpInfoHeader.biWidth;
            height = bmpInfoHeader.biHeight;
            offset = (channels*width) % 4;
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            //bmpImg->mat = kzCreateMat(height, width, 1, 0);  
            bmpImg->width = width;
            bmpImg->height = height;
            bmpImg->channels = 1;
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*height);
            step = channels*width;

            quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 256);
            fread(quad, sizeof(ClRgbQuad), 256, pFile);
            free(quad);

            for (i = 0; i<height; i++)
            {
                for (j = 0; j<width; j++)
                {
                    fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    bmpImg->imageData[(height - 1 - i)*step + j] = pixVal;   //每次一个像素处理
                }
                if (offset != 0)
                {
                    for (j = 0; j<offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    }
                }
            }
        }
        else if (bmpInfoHeader.biBitCount == 24)
        {
            //printf("该位图为位真彩色\n\n");  
            channels = 3;
            width = bmpInfoHeader.biWidth;
            height = bmpInfoHeader.biHeight;

            bmpImg->width = width;
            bmpImg->height = height;
            bmpImg->channels = 3;
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width * 3 * height);
            step = channels*width;

            offset = (channels*width) % 4;
            if (offset != 0)
            {
                offset = 4 - offset;
            }

            fseek(pFile, bmpFileHeader.bfOffBits - sizeof(bmpInfoHeader) - sizeof(bmpFileHeader), SEEK_CUR);  //138-54?感觉应该没有138才对啊

            for (i = 0; i<height; i++)
            {
                for (j = 0; j<width; j++)
                {
                    for (k = 0; k<3; k++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);
                        bmpImg->imageData[(height - 1 - i)*step + j * 3 + k] = pixVal;  //
                    }
                    //kzSetMat(bmpImg->mat, height-1-i, j, kzScalar(pixVal[0], pixVal[1], pixVal[2]));  
                }
                if (offset != 0)
                {
                    for (j = 0; j<offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    }
                }
            }
        }
    }

    return bmpImg;
}

bool clSaveImage(char* path, ClImage* bmpImg)
{
    FILE *pFile;
    unsigned short fileType;
    ClBitMapFileHeader bmpFileHeader;
    ClBitMapInfoHeader bmpInfoHeader;
    int step;
    int offset;
    unsigned char pixVal = '\0';
    int i, j;
    ClRgbQuad* quad;

    pFile = fopen(path, "wb");
    if (!pFile)
    {
        return false;
    }

    fileType = 0x4D42;
    fwrite(&fileType, sizeof(unsigned short), 1, pFile);

    if (bmpImg->channels == 3)//24位，通道，彩图  
    {
        step = bmpImg->channels*bmpImg->width;
        offset = step % 4;
        if (offset != 4)
        {
            step += 4 - offset;
        }

        bmpFileHeader.bfSize = bmpImg->height*step + 54;
        bmpFileHeader.bfReserved1 = 0;
        bmpFileHeader.bfReserved2 = 0;
        bmpFileHeader.bfOffBits = 54;
        fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);

        bmpInfoHeader.biSize = 40;
        bmpInfoHeader.biWidth = bmpImg->width;
        bmpInfoHeader.biHeight = bmpImg->height;
        bmpInfoHeader.biPlanes = 1;
        bmpInfoHeader.biBitCount = 24;
        bmpInfoHeader.biCompression = 0;
        bmpInfoHeader.biSizeImage = bmpImg->height*step;
        bmpInfoHeader.biXPelsPerMeter = 0;
        bmpInfoHeader.biYPelsPerMeter = 0;
        bmpInfoHeader.biClrUsed = 0;
        bmpInfoHeader.biClrImportant = 0;
        fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);

        for (i = bmpImg->height - 1; i>-1; i--)
        {
            for (j = 0; j<bmpImg->width; j++)
            {
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3 + 1];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3 + 2];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
            }
            if (offset != 0)
            {
                for (j = 0; j<offset; j++)
                {
                    pixVal = 0;
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                }
            }
        }
    }
    else if (bmpImg->channels == 1)//8位，单通道，灰度图  
    {
        step = bmpImg->width;
        offset = step % 4;
        if (offset != 4)
        {
            step += 4 - offset;
        }

        bmpFileHeader.bfSize = 54 + 256 * 4 + bmpImg->width;
        bmpFileHeader.bfReserved1 = 0;
        bmpFileHeader.bfReserved2 = 0;
        bmpFileHeader.bfOffBits = 54 + 256 * 4;
        fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);

        bmpInfoHeader.biSize = 40;
        bmpInfoHeader.biWidth = bmpImg->width;
        bmpInfoHeader.biHeight = bmpImg->height;
        bmpInfoHeader.biPlanes = 1;
        bmpInfoHeader.biBitCount = 8;
        bmpInfoHeader.biCompression = 0;
        bmpInfoHeader.biSizeImage = bmpImg->height*step;
        bmpInfoHeader.biXPelsPerMeter = 0;
        bmpInfoHeader.biYPelsPerMeter = 0;
        bmpInfoHeader.biClrUsed = 256;
        bmpInfoHeader.biClrImportant = 256;
        fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);

        quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 256);
        for (i = 0; i<256; i++)
        {
            quad[i].rgbBlue = i;
            quad[i].rgbGreen = i;
            quad[i].rgbRed = i;
            quad[i].rgbReserved = 0;
        }
        fwrite(quad, sizeof(ClRgbQuad), 256, pFile);
        free(quad);

        for (i = bmpImg->height - 1; i>-1; i--)
        {
            for (j = 0; j<bmpImg->width; j++)
            {
                pixVal = bmpImg->imageData[i*bmpImg->width + j];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
            }
            if (offset != 0)
            {
                for (j = 0; j<offset; j++)
                {
                    pixVal = 0;
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                }
            }
        }
    }
    fclose(pFile);

    return true;

}

int rgb24_to_bmp(const char *rgb24path,const char *bmppath,int width,int height)
{
    //定义相应的bmp数据头结构体
    typedef struct 
    {  
        long imageSize;
        long blank;
        long startPosition;
    }BmpHead;

    typedef struct
    {
        long  Length;
        long  width;
        long  height;
        unsigned short  colorPlane;
        unsigned short  bitColor;
        long  zipFormat;
        long  realSize;
        long  xPels;
        long  yPels;
        long  colorUse;
        long  colorImportant;
    }InfoHead;
    
    int i=0,j=0;
    BmpHead m_BMPHeader={0};
    InfoHead  m_BMPInfoHeader={0};
    char bfType[2]={'B','M'};
    int header_size=sizeof(bfType)+sizeof(BmpHead)+sizeof(InfoHead);
    unsigned char *rgb24_buffer=NULL;
    FILE *fp_rgb24=NULL,*fp_bmp=NULL;
    
    if((fp_rgb24=fopen(rgb24path,"rb"))==NULL){
        printf("Error: Cannot open input RGB24 file.\n");
        return -1;
    }
    if((fp_bmp=fopen(bmppath,"wb"))==NULL){
        printf("Error: Cannot open output BMP file.\n");
        return -1;
    }
    
    rgb24_buffer=(unsigned char *)malloc(width*height*3);
    fread(rgb24_buffer,1,width*height*3,fp_rgb24);

    //设置相应的bmp头数据结构
    m_BMPHeader.imageSize=3*width*height+header_size;
    m_BMPHeader.startPosition=header_size;

    m_BMPInfoHeader.Length=sizeof(InfoHead); 
    m_BMPInfoHeader.width=width;
    //BMP storage pixel data in opposite direction of Y-axis (from bottom to top).
    m_BMPInfoHeader.height=-height;
    m_BMPInfoHeader.colorPlane=1;
    m_BMPInfoHeader.bitColor=24;
    m_BMPInfoHeader.realSize=3*width*height;

    fwrite(bfType,1,sizeof(bfType),fp_bmp);
    fwrite(&m_BMPHeader,1,sizeof(m_BMPHeader),fp_bmp);
    fwrite(&m_BMPInfoHeader,1,sizeof(m_BMPInfoHeader),fp_bmp);

    //BMP save R1|G1|B1,R2|G2|B2 as B1|G1|R1,B2|G2|R2
    //It saves pixel data in Little Endian
    //So we change 'R' and 'B'
    for(j =0;j<height;j++){
        for(i=0;i<width;i++){
            char temp=rgb24_buffer[(j*width+i)*3+2];
            rgb24_buffer[(j*width+i)*3+2]=rgb24_buffer[(j*width+i)*3+0];
            rgb24_buffer[(j*width+i)*3+0]=temp;
        }
    }
    //写入相应的bmp数据值部分
    fwrite(rgb24_buffer,3*width*height,1,fp_bmp);
    fclose(fp_rgb24);
    fclose(fp_bmp);
    free(rgb24_buffer);
    printf("Finish generate %s!\n",bmppath);
    return 0;
}

int rgba32_to_bmp(const char *rgba32path,const char *bmppath,int width,int height)
{
    //定义相应的bmp数据头结构体
    typedef struct 
    {  
        long imageSize;
        long blank;
        long startPosition;
    }BmpHead;

    typedef struct
    {
        long  Length;
        long  width;
        long  height;
        unsigned short  colorPlane;
        unsigned short  bitColor;
        long  zipFormat;
        long  realSize;
        long  xPels;
        long  yPels;
        long  colorUse;
        long  colorImportant;
    }InfoHead;
    
    int i=0,j=0;
    BmpHead m_BMPHeader={0};
    InfoHead  m_BMPInfoHeader={0};
    char bfType[2]={'B','M'};
    int header_size=sizeof(bfType)+sizeof(BmpHead)+sizeof(InfoHead);
    unsigned char *rgba32_buffer=NULL;
    unsigned char *rgb24_buffer=NULL;
    FILE *fp_rgba32=NULL,*fp_bmp=NULL;
    
    if((fp_rgba32=fopen(rgba32path,"rb"))==NULL){
        printf("Error: Cannot open input RGB24 file.\n");
        return -1;
    }
    if((fp_bmp=fopen(bmppath,"wb"))==NULL){
        printf("Error: Cannot open output BMP file.\n");
        return -1;
    }
    
    rgba32_buffer=(unsigned char *)malloc(width*height*4);
    rgb24_buffer=(unsigned char *)malloc(width*height*3);
    fread(rgba32_buffer,1,width*height*4,fp_rgba32);
    for (int i=0; i<width*height; i++) {
        rgb24_buffer[i * 3 + 0] = rgba32_buffer[i*4+0];
        rgb24_buffer[i * 3 + 1] = rgba32_buffer[i*4+1];
        rgb24_buffer[i * 3 + 2] = rgba32_buffer[i*4+2];
    }

    //设置相应的bmp头数据结构
    m_BMPHeader.imageSize=3*width*height+header_size;
    m_BMPHeader.startPosition=header_size;

    m_BMPInfoHeader.Length=sizeof(InfoHead); 
    m_BMPInfoHeader.width=width;
    //BMP storage pixel data in opposite direction of Y-axis (from bottom to top).
    m_BMPInfoHeader.height=-height;
    m_BMPInfoHeader.colorPlane=1;
    m_BMPInfoHeader.bitColor=24;
    m_BMPInfoHeader.realSize=3*width*height;

    fwrite(bfType,1,sizeof(bfType),fp_bmp);
    fwrite(&m_BMPHeader,1,sizeof(m_BMPHeader),fp_bmp);
    fwrite(&m_BMPInfoHeader,1,sizeof(m_BMPInfoHeader),fp_bmp);

    //BMP save R1|G1|B1,R2|G2|B2 as B1|G1|R1,B2|G2|R2
    //It saves pixel data in Little Endian
    //So we change 'R' and 'B'
    for(j =0;j<height;j++){
        for(i=0;i<width;i++){
            char temp=rgb24_buffer[(j*width+i)*3+2];
            rgb24_buffer[(j*width+i)*3+2]=rgb24_buffer[(j*width+i)*3+0];
            rgb24_buffer[(j*width+i)*3+0]=temp;
        }
    }
    //写入相应的bmp数据值部分
    fwrite(rgb24_buffer,3*width*height,1,fp_bmp);
    fclose(fp_rgba32);
    fclose(fp_bmp);
    free(rgb24_buffer);
    printf("Finish generate %s!\n",bmppath);
    return 0;
}

int main(int argc, char* argv[])
{
    //All picture's resolution is 1280x720
    //Gray Bar, from 16 to 235
    for (int a=87; a<500; a++) {
        char buff[128] = {0};
        char buff1[128] = {0};
        sprintf(buff,"rgba_%d.rgba",a);
        sprintf(buff1,"rgba_%d.bmp",a);
        rgba32_to_bmp(buff,buff1,3840,1920);
    }
    
    return 0;
}
/*
int main(int argc, char* argv[]) {


    FILE* FFF = fopen(argv[1],"r+");

    ClImage  bbb;
        bbb.width = 3840;
        bbb.height = 1920;
        bbb.channels = 3;
        bbb.imageData = new unsigned char[3840*1920*3];
        char rrr[4] = {0};
    
        for (size_t j = 0; j < 3840*1920; j++)
        {
            fread(rrr,4,1,FFF);
            bbb.imageData[j * 3 + 0] = rrr[0];
            bbb.imageData[j * 3 + 1] = rrr[1];
            bbb.imageData[j * 3 + 2] = rrr[2];
        }
        fclose(FFF);
        char buf[128] = {0};
                
                sprintf(buf,"%s.bmp",argv[1]);
                clSaveImage(buf,&bbb);
                getchar();
    return 0;
}*/

GC286339554
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RGB24/RGBA生成BMP图片代码
07-14 2515
转自：(14条消息) RGB数据保存为BMP图片_yixianfeng41的专栏-CSDN博客 一、BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。 1、BMP文件头（14字节） typedef struct /**** BMP file header structure ****/ { unsigned int bfSize; /* Size of file */ unsigned sho
RGBA数据使用c++存本地bmp文件
yangzm的专栏
05-02 1302
我从内存中的位图想得到其中的buffer数据，而且是32位的rgba 格式的，用下边的函数： 内存中的位图得buffer的方法：其中的回调可以得到数据 void CPaintManagerUI::BitmapCreate(HWND hWnd,HDC dc) { HDC hdcWindow; HDC hdcMemDC = NULL; HBITMAP hbmScreen = NULL; ...
音视频入门基础：像素格式专题（2）——不通过第三方库将RGB24格式视频转换为BMP格式图片
最新发布
崔杰城的博客
05-11 933
BMP取自位图Bitmap的缩写，也称为DIB（与设备无关的位图），是一种独立于显示器的位图数字图像文件格式。常见于微软视窗和OS/2操作系统，Windows GDI API内部使用的DIB数据结构与 BMP 文件格式几乎相同。BMP文件通常是不压缩的，所以它们通常比同一幅图像的压缩图像文件格式要大很多。例如，一张800×600分辨率的24位的BMP格式图片几乎占据1.4MB空间。因此它们通常不适合在因特网或者其他低速或者有容量限制的介质上进行传输。
RGBA图像格式
bmzk123的博客
12-21 4973
RGBA是代表Red（红色）Green（绿色）Blue（蓝色）和Alpha的色彩空间。 alpha通道一般用作不透明度参数。如果一个像素的alpha通道数值为0%，那它就是完全透明的（也就是看不见的），而数值为100%则意味着一个完全不透明的像素（传统的数字图像）。在0%和100%之间的值则使得像素可以透过背景显示出来，就像透过玻璃（半透明性），这种效果是简单的二元透明性（透明或不透明）做不到的。...
【Opencv学习】图像表示原理及BMP格式图像的构成
weixin_42415138的博客
08-25 1672
计算机图像表示原理 计算机图像可以分为两类：位图（Bitmap）和矢量图（Metafile）。位图可以被看做是一个表格，整个图像由许多的矩形块组成，每个矩形代表一个点，点的个数等于位图的横向矩形块的个数乘上纵向矩形块的个数，每一个点则被称为像素点，而且每个像素点都有确定的颜色，因此形成了一幅完整的图像。通常使用的图像大部分是位图，如相机拍摄的照片，因为位图可以表示图像的细节，能够较好的还原现实场景。位图的缺点是体积比较大，因此产生了很多压缩图像格式来存储位图图像，目前应用最广的是JPEG格式，另外还有GIF
PicViewer RGBA32格式查看
12-24
RGBA32格式查看，后续持续更新支持更多格式
BMP图片转RGB数组
12-10
要提取BMP图片的RGB数据并存储到数组，我们首先需要读取BMP文件的头部信息，获取宽度、高度和位深度。然后，我们可以逐行读取位图数据，对于每个像素，我们根据位深度解码其RGB值。在24位BMP中，每个像素占据3个字节...
RGBreader.zip_C++读取bmp rgb_bmp RGB
07-14
4. **解析图像数据**：BMP文件中的像素数据是按行存储的，每个像素通常由3字节（RGB）或4字节（RGBA，包含透明度通道）组成。根据颜色深度，我们可以计算出图像数据的总大小。然后，我们可以逐行读取数据，每次读取...
centos7 png转bmp
11-22
在创建BMP文件的位图信息头时，我们应设置位深度（bit depth）为24（RGB）或32（RGBA）。如果是3通道，我们只需写入RGB值；如果是4通道，则需要在RGB之后加上alpha值。 最后，我们将处理后的像素数据写入BMP文件，...
rgba8888转yuvsp420
10-28
5. **测试和验证**：`32.bmp`和`32.yuv`文件可能用于测试转换的正确性。通过将RGB图像转换为YUV并保存，然后与原始的YUV文件进行比较，可以检查算法的准确性。`YUVViewer.exe`可能是一个用于查看YUV文件的应用，可以...
opencv .jpg格式转化为bmp格式
11-24
与直接用软件转化图片格式不用，此代码可以无损转换图片格式
RGB转BMP工具和源码
11-20
RGB转成BMP的工具和工程源码，实现了rgb图像转换成BMP图像，支持32_ARGB、16_RGB565和16_RGB555三种格式的转换
24位RGB数据保存为BMP图片
06-18
实现过程： A、写入文件头 B、写入信息头 C、写入图像RGB数据 （无调色板） 亲测可以使用
RGB格式转为BMP格式
04-08
RGB格式的文件添加BMP头信息，C代码
Linux 下V4l2摄像头采集图片，实现yuyv转RGB,RGB转BMP，RGB伸缩，RGB转JPEG（保存到内存中），JPEG经UDP发送功能
10-27
ARM Cortex-A8平台Linux下V4l2摄像头采集图片程序，实现yuyv转RGB,RGB转BMP保存，RGB缩放等功能。利用jpeglib实现RGB转JPEG，并且压缩结果保存至内存中，无需再用文件操作来保存JPEG图片，JPEG经UDP发送至远程服务器...
RGBA转换成RGB
梦想之路
01-20 2万+
刚毕业半年，毕业才开始接触UI，现在的系统支持RGB模式显示，但是需要RGBA透明色来描边，所以粗略学习了下。 个人理解RGBA中的A是相对的，也就是一个背景色。 所以假设背景颜色的值为(bg.r, bg.g, bg.b)， 而需要设置的透明色（RGBA模式）为(color.r, color.g, color.b, a)           a为小数 目标值
ARGB与RGB、RGBA的区别
热门推荐
caption_deng的博客
08-30 5万+
ARGB 是一种色彩模式，也就是RGB色彩模式附加上Alpha（透明度）通道，常见于32位位图的存储结构。RGB 色彩模式是工业界的一种颜色标准，是通过对红(R)、绿(G)、蓝(B)三个颜色通道的变化以及它们相互之间的叠加来得到各式各样的颜色的，RGB即是代表红、绿、蓝三个通道的颜色，这个标准几乎包括了人类视力所能感知的所有颜色，是目前运用最广的颜色系统之一。RGBA 是代表Red（红色） Gree
RGB24转换成BMP图像
liaojunwu的博客
09-01 5020
最近学习雷神的博客, RGB24转换成BMP位图, 发现一些问题与心得, 记录下来 1.位图知识:(会列出两篇比较好的博文, 这里简单总结一下) 位图结构: 位图文件头(14字节) 位图信息头(40字节) 彩色表(RGB24真彩不存在彩色表) 位图数据(实际上就是RGB数据) 【注意1】:位图文件头与位图信息头一共是54字节, 雷神在博文里写的结构体不正确, 正确的结构体如下: 贴...
C++ Cimage的bmp图片转png，并透明
05-24
在这个示例中，我们首先使用 CImage 类加载 BMP 图像文件。然后，我们遍历每个像素，并将其值转换为 PNG 格式，同时添加透明度（即，如果像素值为 RGB(255, 0, 255)，则将其 alpha 值设置为 0，否则将其 alpha 值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值