png和bmp图片像素读取（linux）

最新推荐文章于 2024-05-30 10:11:15 发布
最新推荐文章于 2024-05-30 10:11:15 发布
阅读量4.7k 收藏 5
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012000056/article/details/54286003
版权

查找当前目录下的png和bmp图片，将其像素点读取出来压缩进theme.bin中，并将图片的其他信息如宽高压缩前后大小和在theme.bin中的偏移位置保存在bmpaddr.h中，方便在其他代码中读取图片像素信息。

main.c

#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <zlib.h>

#include <png.h>
#include <setjmp.h>

#include "Userdefine.h"
#include "bmp.h"

#define MAX_IMAGE_FILE_NUM (512)
#define MAX_NAME_LEN (128)

typedef struct
{
    char acName[MAX_NAME_LEN];
    char acBaseName[MAX_NAME_LEN];
}IMAGE_NAME;

typedef struct
{
    IMAGE_NAME stImageName[MAX_IMAGE_FILE_NUM];
    unsigned int uiTotalPNGFile;
    unsigned int uiTotalBMPFile;
}IMAGE_FILE;

#define FORMAT "#define %-60s"
#define HEADER_MARO ("_BMPADDR_H_")
#define HEADER_FILE ("bmpaddr.h")
#define BIN_FILE ("theme.bin")
#define DIR_PATH ("./")
IMAGE_FILE stImageFile;
FILE *pfHeaderFile = NULL;
FILE *pfBinFile = NULL;
static int iAddr = 0x0;

const unsigned char ucPNGHeadData[] = {0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0xa};

#define BMP_INDEX(x) (MAX_IMAGE_FILE_NUM - x - 1)

void HandleFileName(char *pucFileName, unsigned int uiFileLen)
{
    unsigned int uiIndex = 0;
    char cTemp = 0;

    if(pucFileName == NULL || uiFileLen <= 0)
    {
        return;
    }

    for(uiIndex = 0; uiIndex < uiFileLen; uiIndex++)
    {
        cTemp = pucFileName[uiIndex];
        if(cTemp >= 'a' && cTemp <= 'z')
        {
            cTemp -= 32;
        }
        else if(!((cTemp >= 'A' && cTemp <= 'Z') || (cTemp >= '0' && cTemp <= '9')))
        {
            cTemp = '_';
        }
        pucFileName[uiIndex] = cTemp;
    }
}

void FindAllImageFile()
{
    struct dirent *pstDirent = NULL;
    DIR *pstDir;
    IMAGE_NAME *pstTemp = NULL;
    BOOL bFound = FALSE;

    memset(&stImageFile, 0, sizeof(stImageFile));

    pstDir = opendir(DIR_PATH);
    while(NULL != (pstDirent = readdir(pstDir)))
    {
        bFound = FALSE;
        if(8 == pstDirent->d_type)
        {
            if((stImageFile.uiTotalPNGFile + stImageFile.uiTotalBMPFile) < MAX_IMAGE_FILE_NUM)
            {
                if(strstr(pstDirent->d_name, ".png") || strstr(pstDirent->d_name, ".PNG"))
                {
                    pstTemp = &(stImageFile.stImageName[stImageFile.uiTotalPNGFile]);
                    stImageFile.uiTotalPNGFile++;
                    bFound = TRUE;
                }
                else if(strstr(pstDirent->d_name, ".bmp") || strstr(pstDirent->d_name, ".BMP"))
                {
                    pstTemp = &(stImageFile.stImageName[MAX_IMAGE_FILE_NUM - stImageFile.uiTotalBMPFile - 1]);
                    stImageFile.uiTotalBMPFile++;
                    bFound = TRUE;
                }

                if(bFound)
                {
                    snprintf(pstTemp->acName, sizeof(pstTemp->acName), "%s", pstDirent->d_name);
                    snprintf(pstTemp->acBaseName, sizeof(pstTemp->acBaseName), "%s", pstDirent->d_name);
                    HandleFileName(pstTemp->acBaseName, strlen(pstTemp->acBaseName));
                }
            }
        }
    }

    closedir(pstDir);
}

void SortImageFile()
{
    int iIndex = 0;
    int iTemp = 0;
    IMAGE_NAME stTemp;
    int iIndexTemp = 0;
    int iTempIndex = 0;

    for(iIndex = 0; iIndex < stImageFile.uiTotalPNGFile; iIndex++)
    {
        stTemp = stImageFile.stImageName[iIndex];
        for(iTemp = iIndex + 1; iTemp < stImageFile.uiTotalPNGFile; iTemp++)
        {
            if(strcmp(stTemp.acBaseName, stImageFile.stImageName[iTemp].acBaseName) > 0)
            {
                stImageFile.stImageName[iIndex] = stImageFile.stImageName[iTemp];
                stImageFile.stImageName[iTemp] = stTemp;
                stTemp = stImageFile.stImageName[iIndex];
            }
        }
    }

    for(iIndex = 0; iIndex < stImageFile.uiTotalBMPFile; iIndex++)
    {
        iIndexTemp = BMP_INDEX(iIndex);
        stTemp = stImageFile.stImageName[iIndexTemp];
        for(iTemp = iIndex + 1; iTemp < stImageFile.uiTotalBMPFile; iTemp++)
        {
            iTempIndex = BMP_INDEX(iTemp);
            if(strcmp(stTemp.acBaseName, stImageFile.stImageName[iTempIndex].acBaseName) > 0)
            {
                stImageFile.stImageName[iIndexTemp] = stImageFile.stImageName[iTempIndex];
                stImageFile.stImageName[iTempIndex] = stTemp;
                stTemp = stImageFile.stImageName[iIndexTemp];
            }
        }
    }
}

void FlipImage(unsigned char * ucImgBuff, int iWidth, int iHeight)
{
    unsigned char *pucLineBuf = NULL;
    int iIndexY = 0;
    unsigned char *pucHead = NULL;
    unsigned char *pucTail = NULL;

    pucLineBuf = (unsigned char *)malloc(iWidth * 4);
    if(pucLineBuf == NULL)
    {
        printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
        return;
    }

    for(iIndexY = 0; iIndexY < iHeight / 2; ++iIndexY)
    {
        pucHead = ucImgBuff + iIndexY * iWidth * 4;
        pucTail = ucImgBuff + (iHeight - iIndexY - 1) * iWidth * 4;
        memcpy(pucLineBuf, pucHead, iWidth * 4);
        memcpy(pucHead, pucTail, iWidth * 4);
        memcpy(pucTail, pucLineBuf, iWidth * 4);
    }

    free(pucLineBuf);
    pucLineBuf = NULL;
}

void WriteToFile(int iStartAddr, int iWidth, int iHeight, unsigned char *pucPicBuffer, char *acBaseName)
{
    uLongf iDataLenBeforeCompress = iWidth * iHeight * 4;
    uLongf iDataLenAfterCompress = compressBound(iDataLenBeforeCompress);
    int iRet = 0;
    char acTempBuffer[1024];
    unsigned char acName[128];
    unsigned char *pucCompressData = NULL;

    do
    {
        pucCompressData = (unsigned char *)malloc(iDataLenAfterCompress);
        if(pucCompressData == NULL)
        {
            printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
            break;
        }

        iRet = compress(pucCompressData, &iDataLenAfterCompress, pucPicBuffer, iDataLenBeforeCompress);
        if(Z_OK != iRet)
        {
            printf("===>[%s, %d]%d\n", __FUNCTION__, __LINE__, iRet);
            break;
        }

        if(pfHeaderFile)
        {
            int iTempOffset = (4 - (iDataLenAfterCompress % 4));

            snprintf(acName, sizeof(acName), "%s", acBaseName);
            snprintf(acTempBuffer, sizeof(acTempBuffer), FORMAT" 0x%x\n", acName, iAddr);
            fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

            snprintf(acName, sizeof(acName), "%s_SIZE", acBaseName);
            snprintf(acTempBuffer, sizeof(acTempBuffer), FORMAT" %d\n", acName, iDataLenBeforeCompress);
            fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

            snprintf(acName, sizeof(acName), "%s_COMPRESS_SIZE", acBaseName);
            snprintf(acTempBuffer, sizeof(acTempBuffer), FORMAT" %d\n", acName, iDataLenAfterCompress);
            fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

            snprintf(acName, sizeof(acName), "%s_WIDTH", acBaseName);
            snprintf(acTempBuffer, sizeof(acTempBuffer), FORMAT" %d\n", acName, iWidth);
            fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

            snprintf(acName, sizeof(acName), "%s_HEIGHT", acBaseName);
            snprintf(acTempBuffer, sizeof(acTempBuffer), FORMAT" %d\n\n", acName, iHeight);
            fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

            if(pfBinFile)
            {
                char acTemp[8];
                memset(acTemp, 0, sizeof(acTemp));

//              printf("===>[%s, %d]%x\n", __FUNCTION__, __LINE__, ftell(pfBinFile));
                fwrite(pucCompressData, iDataLenAfterCompress, 1, pfBinFile);
                fwrite(acTemp, iTempOffset, 1, pfBinFile);
            }

            iAddr = iAddr + iDataLenAfterCompress + iTempOffset;
        }
    }while(0);

    if(pucCompressData)
    {
        free(pucCompressData);
        pucCompressData = NULL;
    }
}

#define PNG_BYTES_TO_CHECK 4
void UseLibPNGToLoadPNGFile(IMAGE_NAME stFileName)
{
    FILE *fp;
    png_structp png_ptr;
    png_infop info_ptr;
    png_bytep* row_pointers;
    char buf[PNG_BYTES_TO_CHECK];
    int iWidth, iHeight, iIndexX, iIndexY, iTemp, iColorType;
    BOOL bGetImageData = FALSE;
    unsigned char *pucImageBuffer = NULL;

    if(strlen(stFileName.acName) <= 0 || strlen(stFileName.acBaseName) <= 0)
    {
        printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
        return;
    }

    do
    {
        fp = fopen(stFileName.acName, "rb");
        if(fp == NULL)
        {
            break;
        }

        png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0);
        info_ptr = png_create_info_struct(png_ptr);

        setjmp(png_jmpbuf(png_ptr));

        iTemp = fread(buf, 1, PNG_BYTES_TO_CHECK, fp);
        if(iTemp < PNG_BYTES_TO_CHECK)
        {
            break;
        }

        iTemp = png_sig_cmp((png_bytep)buf, (png_size_t)0, PNG_BYTES_TO_CHECK);
        if(iTemp != 0)
        {
            break;
        }

        rewind(fp);
        png_init_io(png_ptr, fp);
        png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND, 0);

        iColorType = png_get_color_type(png_ptr, info_ptr);
        iWidth = png_get_image_width(png_ptr, info_ptr);
        iHeight = png_get_image_height(png_ptr, info_ptr);
        row_pointers = png_get_rows(png_ptr, info_ptr);
//      printf("===>[%s, %d]%d %d %d\n", __FUNCTION__, __LINE__, iWidth, iHeight, iColorType);
        pucImageBuffer = (unsigned char *)malloc(iWidth * iHeight * 4);
        if(pucImageBuffer == NULL)
        {
            break;
        }
        bGetImageData = FALSE;
        switch(iColorType)
        {
            case PNG_COLOR_TYPE_RGB_ALPHA:
                for(iIndexY = 0; iIndexY < iHeight; ++iIndexY)
                {
                    for(iIndexX = 0; iIndexX < iWidth * 4; iIndexX += 4)
                    {
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX + 2) = row_pointers[iIndexY][iIndexX + 0];//r
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX + 1) = row_pointers[iIndexY][iIndexX + 1];//g
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX + 0) = row_pointers[iIndexY][iIndexX + 2];//b
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX + 3) = row_pointers[iIndexY][iIndexX + 3];//a
                    }
                }
                bGetImageData = TRUE;
                break;

            case PNG_COLOR_TYPE_RGB:
            {
                int iTempIndex = 0;
                for(iIndexY = 0; iIndexY < iHeight; ++iIndexY)
                {
                    for(iIndexX = 0; iIndexX < iWidth * 3;iIndexX +=3)
                    {
                        iTempIndex = (iIndexX / 3) * 4;
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iTempIndex + 2) = row_pointers[iIndexY][iIndexX + 0];
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iTempIndex + 1) = row_pointers[iIndexY][iIndexX + 1];
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iTempIndex + 0) = row_pointers[iIndexY][iIndexX + 2];
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iTempIndex + 3) = 0xff;
                    }
                }
                bGetImageData = TRUE;
            }
                break;

            default:
                break;
        }

        if(bGetImageData)
        {
//          FlipImage(pucImageBuffer, iWidth, iHeight);
            WriteToFile(iAddr, iWidth, iHeight, pucImageBuffer, stFileName.acBaseName);
        }
    }while(0);

    if(pucImageBuffer)
    {
        free(pucImageBuffer);
        pucImageBuffer = NULL;
    }

    if(fp)
    {
        fclose(fp);
        fp = NULL;
    }

    png_destroy_read_struct( &png_ptr, &info_ptr, 0);
}


void LoadBMPFile(IMAGE_NAME stFileName)
{
    FILE *fp = NULL;
    BITMAPFILEHEADER stPicHead;
    BITMAPINFOHEADER stPicInfoHead;
    int iWidth = 0;
    int iHeight = 0;
    int iBitCount = 0;
    int iLineByte = 0;
    unsigned char *pucPicBuffer = NULL;
    unsigned char *pucImageBuffer = NULL;

    if(strlen(stFileName.acName) <= 0 || strlen(stFileName.acBaseName) <= 0)
    {
        printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
        return;
    }

    do
    {
        fp = fopen(stFileName.acName, "rb");
        if(fp == NULL)
        {
            printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
            break;
        }

        fread(&stPicHead.bfType, sizeof(stPicHead.bfType), 1, fp);
        fread(&stPicHead.bfSize, sizeof(stPicHead.bfSize), 1, fp);
        fread(&stPicHead.bfReserved1, sizeof(stPicHead.bfReserved1), 1, fp);
        fread(&stPicHead.bfReserved2, sizeof(stPicHead.bfReserved2), 1, fp);
        fread(&stPicHead.bfOffBits, sizeof(stPicHead.bfOffBits), 1, fp);

        if(stPicHead.bfType != 0x4D42)
        {
            printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
            break;
        }

        fread(&stPicInfoHead, 1, sizeof(stPicInfoHead), fp);
        iWidth = stPicInfoHead.biWidth;
        iHeight = stPicInfoHead.biHeight;
        iBitCount = stPicInfoHead.biBitCount;
//      printf("===>[%s, %d]%d %d %d\n", __FUNCTION__, __LINE__, iWidth, iHeight, iBitCount);
//      printf("===>[%s, %d]%d %x\n", __FUNCTION__, __LINE__, stPicInfoHead.biSize, stPicInfoHead.biSizeImage);

        if(iBitCount == 24 || iBitCount == 32)
        {
            int iIndexY = 0;
            int iIndexX = 0;
            iLineByte = (iWidth*iBitCount / 8 + 3) / 4 * 4;
            pucPicBuffer = (unsigned char *)malloc(iHeight * iLineByte);
            if(NULL == pucPicBuffer)
            {
                printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
                break;
            }

            pucImageBuffer = (unsigned char *)malloc(iHeight * iWidth * 4);
            if(NULL == pucImageBuffer)
            {
                printf("===>[%s, %d]\n", __FUNCTION__, __LINE__);
                break;
            }

            fread(pucPicBuffer, 1, iHeight * iLineByte, fp);
//          printf("===>[%s, %d]%x\n", __FUNCTION__, __LINE__, iHeight * iLineByte);

            FlipImage(pucPicBuffer, iLineByte / 4, iHeight);
            if(iBitCount == 24)
            {
                for(iIndexY = 0; iIndexY < iHeight; ++iIndexY)
                {
                    for(iIndexX = 0; iIndexX < iWidth; ++iIndexX)
                    {
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 0) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 3 + 0);//b
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 1) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 3 + 1);//g
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 2) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 3 + 2);//r
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 3) = 0xff;
                    }
                }
            }
            else if(iBitCount == 32)
            {
                for(iIndexY = 0; iIndexY < iHeight; ++iIndexY)
                {
                    for(iIndexX = 0; iIndexX < iWidth; ++iIndexX)
                    {
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 0) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 4 + 0);//b
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 1) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 4 + 1);//g
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 2) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 4 + 2);//r
                        *(pucImageBuffer + iIndexY * iWidth * 4 + iIndexX * 4 + 3) = *(pucPicBuffer + iIndexY * iLineByte + iIndexX * 4 + 3);//a
                    }
                }
            }

            WriteToFile(iAddr, iWidth, iHeight, pucImageBuffer, stFileName.acBaseName);
        }
    }while(0);

    if(fp)
    {
        fclose(fp);
        fp = NULL;
    }

    if(pucPicBuffer)
    {
        free(pucPicBuffer);
        pucPicBuffer = NULL;
    }

    if(pucImageBuffer)
    {
        free(pucImageBuffer);
        pucImageBuffer = NULL;
    }
}

void HandleImageFile()
{
    int iIndex = 0;
    IMAGE_NAME stTemp;
    int iIndexTemp = 0;
    char acTempBuffer[1024];

    do
    {
        pfHeaderFile = fopen(HEADER_FILE, "w");
        if(pfHeaderFile == NULL)
        {
            break;
        }

        pfBinFile = fopen(BIN_FILE, "w");
        if(pfBinFile == NULL)
        {
            break;
        }

        snprintf(acTempBuffer, sizeof(acTempBuffer), "#ifndef %s\n", HEADER_MARO);
        fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

        snprintf(acTempBuffer, sizeof(acTempBuffer), "#define %s\n\n", HEADER_MARO);
        fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);

        DEBUG_DEB("Total %d PNG file.\n", stImageFile.uiTotalPNGFile);
        for(iIndex = 0; iIndex < stImageFile.uiTotalPNGFile; iIndex++)
        {
            stTemp = stImageFile.stImageName[iIndex];
            UseLibPNGToLoadPNGFile(stTemp);
        }

        DEBUG_DEB("Total %d BMP file.\n", stImageFile.uiTotalBMPFile);
        for(iIndex = 0; iIndex < stImageFile.uiTotalBMPFile; iIndex++)
        {
            iIndexTemp = BMP_INDEX(iIndex);
            stTemp = stImageFile.stImageName[iIndexTemp];
            LoadBMPFile(stTemp);
        }

        snprintf(acTempBuffer, sizeof(acTempBuffer), "#endif\n");
        fwrite(acTempBuffer, strlen(acTempBuffer), 1, pfHeaderFile);
    }while(0);

    if(pfHeaderFile)
    {
        fclose(pfHeaderFile);
        pfHeaderFile = NULL;
    }

    if(pfBinFile)
    {
        fclose(pfBinFile);
        pfBinFile = NULL;
    }
}

int main(int argc, char *argv[])
{
    FindAllImageFile();
    if(stImageFile.uiTotalBMPFile + stImageFile.uiTotalPNGFile > 0)
    {
        SortImageFile();
        HandleImageFile();
    }

    return 0;
}

bmp.h

#ifndef BMP_H_
#define BMP_H_

typedef unsigned int   DWORD;
typedef unsigned short  WORD;
typedef unsigned char  BYTE;
typedef  long                   LONG;

typedef struct tagBITMAPFILEHEADER {
    WORD    bfType;
    DWORD   bfSize;
    WORD    bfReserved1;
    WORD    bfReserved2;
    DWORD   bfOffBits;
} BITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{
    DWORD  biSize;
    DWORD   biWidth;
    DWORD   biHeight;
    WORD   biPlanes;
    WORD   biBitCount;
    DWORD  biCompression;
    DWORD  biSizeImage;
    DWORD   biXPelsPerMeter;
    DWORD   biYPelsPerMeter;
    DWORD  biClrUsed;
    DWORD  biClrImportant;
} BITMAPINFOHEADER;

typedef struct tagRGBQUAD { // rgbq
   BYTE    rgbBlue;
   BYTE    rgbGreen;
   BYTE    rgbRed;
   BYTE    rgbReserved;
} RGBQUAD;

#endif /* BMP_H_ */

Userdefine.h

#ifndef USERDEFINE_H_
#define USERDEFINE_H_

#if 1
#define DEBUG_DEB(fmt, arg...) printf("[DEBUG][%s,%d]"fmt, __FUNCTION__, __LINE__, ##arg)
#else
#define DEBUG_DEB(fmt, arg...)
#endif

#if 0
#define DEBUG_INFO(fmt, arg...) printf("[DEBUG][%s,%d]"fmt, __FUNCTION__, __LINE__, ##arg)
#else
#define DEBUG_INFO(fmt, arg...)
#endif

#if 1
#define DEBUG_ERR(fmt, arg...) printf("[ERROR][%s,%d]"fmt, __FUNCTION__, __LINE__, ##arg)
#else
#define DEBUG_ERR(fmt, arg...)
#endif

typedef enum
{
    FALSE,
    TRUE,
}BOOL;

typedef unsigned int U32;

#endif /* USERDEFINE_H_ */
mkchiny
关注
Linux应用开发-LCD显示BMP图片
05-03 3039
为了解BMP格式，这篇文章就采用Linux开发板作为实验平台，在LCD屏上读取BMP图片，完成绘制，不需要借助任何第三方库，全部由纯C语言代码一行一行敲出来，深入理解Linux下帧缓冲编程框架、BMP图片的存储结构原理。
c++读写BMP JPG 和png 的图像文件（linux）
11-27
本程序借助libpng和libjpeg库 ，以C++类的方式实现linux下对png jpg和bmp常见类型的图像文件的读写。要在程序中显示图像可自行用opengl或其他方式完成。
BMP和png格式的区别
JLY19970726的博客
05-30 980
综上所述，BMP和PNG在压缩方式、颜色深度、透明度支持、适用范围和文件大小等方面存在显著差异。在选择使用哪种格式时，应根据具体需求和场景进行权衡。如果需要保持图像数据的原始性或者进行高质量的打印输出，BMP可能是一个更好的选择。而如果需要进行网络传输、网页设计或图像处理等操作，并且希望文件大小较小且支持透明度效果，那么PNG则是一个更合适的选择。
Linux下查看图片中某点的像素X、Y坐标
专注“目标检测”领域技术分享
03-09 1911
Linux下查看图片中某点的像素X、Y坐标
linux编程读取bmp图片像素,获取BMP文件的像素值
weixin_32199769的博客
05-14 674
注意:如果BMP有alpha通道,可能需要为alpha值抓取一个额外的字节。在这种情况下,图像将是image[pixelcount][4],然后再添加一个getc(streamIn)保存第四个索引的行。我的BMP原来不需要那个。// super-simplified BMP read algorithm to pull out RGB data// read image for coloring ...
linux 读取png图片大小,读取 png 图片的宽高信息
weixin_35851515的博客
05-04 1029
#include // 保留，在读取 png 头部信息的是，每次读取到 0D 0A 读取就会产生错误，如果 0D 0A 修改为其他的数据，则数据可以正常读取，不知道为什么 ----文件打开的时候， 将读取文件的方式设置为 二进制 流文件读取就可以。//typedef struct//{//char HeadInfo[8];// 文件头信息//int IhderChu...
Ubuntu: 查看图像像素坐标
SSS_369
08-02 5861
介绍UBuntu下查看图像像素坐标的软件mtPoint 安装命令: sudo apt-get install mtpaint
linux 终端图像查看,Linux终端中查看图像的方法
weixin_30811273的博客
05-03 1027
Linux有很多用于查看图像的GUI应用。但我从来没有尝试过用任何命令行应用来查看它。幸运的是，在使用ImageMagick工具时，我得到了一个从终端查看图像的命令。命令名是“display，它是ImageMagick工具的一部分。这是一个很好的工具，允许类UNIX用户从终端查看图像。此外，我还为此用途得到了另一个很好的工具，叫做FIM。我们将向你展示如何安装并使用它从Linux终端查看图像。这些...
linux　如何查看bmp文件数据_如何在Linux上查看图像元数据
weixin_29557763的博客
12-23 1517
本文译自：How To View Image Metadata On Linux译者：EmuLab原文链接：原文遵循：[CC BY-NC协议]图像元数据是一系列关于图像的信息。元数据要么被嵌入到了图像中，要么别存储在一个单独的文件中。总共有三种类型的元数据，它们是:技术性元数据描述性元数据管理性元数据就如名字所体现的一样，技术性元数据通常包含一个图像的技术性信息，比如相机参数，DPI，快门速度，文...
图片格式 NV21 转 RGB24 和 BMP图片源码（C语言）。
04-12
源码会包含读取NV21数据，进行色彩空间转换，以及构建和写入BMP文件头的函数。转换过程中可能涉及到内存分配、像素遍历、位运算等技巧。 6. **直接可用**：提供的源码应该是经过测试的，可以直接在C编译环境中运行...
centos7 png转bmp
11-22
libpng是一个官方支持的PNG库，提供了读取、写入和处理PNG文件的API。同样，对于BMP文件的处理，我们可以直接操作文件结构，因为它的格式相对简单。 在转换过程中，我们首先要读取PNG文件并解析其内容。libpng库...
png图片转bmp图片
07-30
PNG图片转BMP图片的实现涉及到图像处理的原理和编程技巧。首先，我们需要理解这两种格式的基本结构。PNG采用压缩存储，包括索引颜色、真彩色以及灰度图像，支持透明度；BMP则是一个非压缩格式，其数据通常按照从下到...
linux下通过C语言读取BMP格式图片，在文本终端显示该图片
Noreason_to_down的博客
06-29 8323
记录读出BMP格式图片的过程，并在屏幕上显示； 如有错误欢迎指正，如需转载请注明出处。
Linux 下bmp文件的读写操作
jianminfly的博客
03-10 1088
1.写操作 int bmp_write(unsigned char* image, int imageWidth, int imageHeight, const char* filename){ long extrabytes = 4 - ((imageWidth * 3) % 4); if (extrabytes == 4) extrabytes = 0; long paddedsize = ((imageWidth * 3) + extrabytes) * imageHeight; unsi
Linux 图片全屏缩放 c,RGB源数据操作: 实现图片放大、缩小
weixin_34551660的博客
05-14 833
一、运行环境介绍Linux系统: Redhat6.3 (32位)gcc 版本 4.4.6 20120305 (Red Hat 4.4.6-4) (GCC)二、功能介绍打开一张BMP图片，读取RGB源数据进行缩放再生成新的BMP图片。三、核心代码由于处理的是BMP图片数据，传入的缩放后的图片宽度需要是4的倍数.#include #include #include int PicZoom(unsign...
linux读取bmp图片数据,linux下读取bmp图片文件头
weixin_35983453的博客
05-12 979
建议先了解下BMP图片格式.条件：1.用windows画图工具另存的一张BMP格式图片；2.linux或ubuntu下vim编译器#include#include#include#include #pragma pack(2) //对齐using namespace std;typedef struct BITMAPFILEHEADER{u_int16_t bfType;u_int32_t b...
linux图像显示（二）bmp图片
JT同学的博客
12-08 5901
linux图像显示 linux图像显示（一）framebuffer操作 linux图像显示（二）bmp图片 linux图像显示（三）使用libjpg处理jpg图片 linux图像显示（四）使用libpng处理png图片 linux图像显示（五）使用freetype处理矢量字体 BMP图片是未经压缩的图片，其内容包括头信息和颜色有效信息 头信息包括下面几个部分：文件头，信息头，调...
linux 读取png图片大小,使用libpng读取PNG图片像素数据
weixin_32999557的博客
05-04 1040
附录 让我们打开pnglib下面的一个example.c/* Read a PNG file. You may want to return an error code if the read* fails (depending upon the failure). There are two "prototypes" given* here - one where we are given t...
机械原理课程设计 破碎机.doc
最新发布
09-21
机械原理课程设计 破碎机.doc
Qt 读取png图片转换到像素值
06-03
要读取PNG图片并将其转换为像素值，可以使用Qt中的QImage类。可以使用以下代码： ``` #include #include int main() { QImage image("image.png"); // 加载PNG图片 if (image.isNull()) { qDebug() !"; ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值