c语言如何读取图片中的像素值

㈠ C++中如何获取图片的像素值

用gdi+ 、OpenCV、cximge、freeimage等等库 都有方法加载图像，然后获取对象的像素:
比如用gdi+：
1、#include "GdiPlus.h"
#pragma comment(lib, "gdiplus.lib")
2、初始化gdi+（具体可以网络下：）
3、Bitmap image(文件名);
int w = image.GetWidth();
int h = image.GetHeight()。

㈡ 如何在VC中读取彩色BMP格式的图像的像素值，急！麻烦各位高手帮帮忙啦！

，所以只做了处理24位位图和32位位图的功能，1、4、8、16位位图从原理上来说是一样的，不过情况稍微复杂一点。你自己解决吧。

//注意，运行时必须要在控制台（cmd窗口）运行，如果直接在编译器那里编译时，是看不到希望的结果的。有问题的话这两天可以网络找我，再过几天就回家了，得明年才回来。

#include<windows.h>
#include<iostream>
#include<fstream>
#include <iomanip>
using namespace std;
/*
位图文件分四个部分：
1.文件头
2.文件信息头
3.调色板
4.实际位图数据

//位图文件文件头，2*3+4*2=14字节
typedef struct tagBITMAPFILEHEADER
{
WORD bfType;//文件类型，必须为0x424D，由于WORD类型存放数据是先低字节、再高字节，所以实际上在判断时要用0x4d42（见代码，或者可直接用10进制的数19778），即"BM"，'B'=0x42，'M'='0x4d'
DWORD bfSize;//文件大小
WORD bfReserved1;//保留字，必须设置为0，可不考虑，下同
WORD bfReserved2;
DWORD bfOffBits;//文件头到实际位图数据的偏移字节数，即前三部分长度之和
}BITMAPFILEHEADER;

//文件信息头，2*2+4*9=40字节
typedef struct tagBITMAPINFOHEADER
{
DWORD biSize;//此结构长度，为40
LONG biWidth;//图像宽度，单位为像素
LONG biHeight;//图像高度，单位为像素
WORD biPlanes;//必须为1
WORD biBitCount;//颜色位数，常用有：1（黑白2色图）、4（16色图）、8（256色图）、24（真彩色图）。新bmp格式还支持32位（增强型真彩色图）
DWORD biCompression;//指定位图是否压缩，有效值：BI_RGB、BI_RLE8、BI_RLE4、BI_BITFIELDS，均为Windows定义好的常量
DWORD biSizeImage;//实际位图数据占用的字节数
LONG biXPelsPerMeter;//目标设备水平分辨率，单位：像素/米
LONG biYPelsPerMeter;//目标设备垂直分辨率，单位：像素/米
DWORD biClrUsed;//图像实际用的到颜色数，如果为0，则实际用到的颜色数为：2的biBitCount次方
DWORD biClrImportant;//重要的颜色数，为0时表示所有颜色都重要
}BITMAPINFOHEADER;

//位图调色板（真彩色不需要），是一个数组，共biClrUsed个元素，若该值为0，则共有2的biBitCount次方个元素。每个元素是一个颜色表结构：
//颜色表结构
typedef struct tagRGBQUAD
{
BYTE rgbBlue; //蓝色分量
BYTE rgbGreen; //绿色分量
BYTE rgbRed; //红色分量
BYTE rgbReserved;//保留值
}RGBQUAD;
*/
class CBmp
{
public:
//读图像文件信息
bool ReadInfo(char FilePath[]);
//写图像灰度信息到文本文件
bool WriteToTxt(char FilePath[]);

CBmp();
virtual ~CBmp();

private:
BITMAPFILEHEADER m_sBMFH; //位图文件头
BITMAPINFOHEADER m_sBMIH; //位图信息头
RGBQUAD * m_pPalette; //调色板
BYTE * m_pBData; //位图数据
};

CBmp::CBmp()
{
m_pPalette = NULL;
m_pBData = NULL;
}
CBmp::~CBmp()
{
if(m_pPalette!=NULL)
{
delete [] m_pPalette;
m_pPalette = NULL;
}
if(m_pBData!=NULL)
{
delete [] m_pBData;
m_pBData = NULL;
}
}

//读图像文件
bool CBmp::ReadInfo(char FilePath[])
{
int nSize; //用来记录调色板的大小
ifstream fin;
fin.open(FilePath,ios::binary);
if(!fin)
{
cerr<<"Open file error!"<<endl;
return false;
}
//读取文件头
fin.read((char *)(&m_sBMFH),sizeof(BITMAPFILEHEADER));
// 判断是否BMP格式
if(m_sBMFH.bfType!=0x4d42)
{
cout<<"该文件不是BMP格式的文件！"<<endl;
return false;
}
//读取文件信息头
fin.read((char *)(&m_sBMIH),sizeof(BITMAPINFOHEADER));
//计算调色板的大小
nSize = m_sBMFH.bfOffBits - sizeof(BITMAPFILEHEADER) - sizeof(BITMAPINFOHEADER);
if(nSize!=0)
{
//读取调色板
m_pPalette = new RGBQUAD [nSize/4];
fin.read((char *)(m_pPalette),nSize);
}
//读取图像数据
m_pBData = new BYTE [m_sBMIH.biSizeImage];
fin.read((char *)(m_pBData),m_sBMIH.biSizeImage);
return true;
}
//写图像灰度信息到文本文件
bool CBmp::WriteToTxt(char FilePath[])
{
// 选用的灰度转换公式不同，所得的结果基本上是一致的，但是会稍有差别。
// Gray = (R*38 + G*75 + B*15) >> 7; //高精度转灰度公式
// Gray = R*0.299 + G*0.587 + B*0.114 //使用浮点计算，速度较慢
int k = 0,i,j;
int r,g,b;
int Gray;
BYTE *pt;
ofstream fout;
int t=0;
j = strlen(FilePath);
char *TxtFilePath = new char [j+1]; //记录灰度值的文本文件路径
TxtFilePath[j-3] = 't';
TxtFilePath[j-2] = 'x';
TxtFilePath[j-1] = 't';
TxtFilePath[j] = '\0';
for(i=j-4;i>=0;i--)
TxtFilePath[i] = FilePath[i] ;
switch(m_sBMIH.biBitCount)
{
case 1: //1、4、8位的位图有调色板，要先读取调色板，根据索引找到真实的图像RGB值，再转换。
cout<<"黑白2色(1位)位图的处理暂未实现！"<<endl;
break;
case 4:
cout<<"16色(4位)位图的处理暂未实现！"<<endl;
break;
case 8:
cout<<"256色(8位)位图的处理暂未实现"<<endl;
break;
case 16: //16位位图无调色板，一般为前5位记录R值，中6位记录G值，后5位记录B值
cout<<"16位位图的处理暂未实现"<<endl;
break;
case 24:
if(m_sBMIH.biWidth*3%4!=0)t=4-m_sBMIH.biWidth*3%4; //位图数据要求每行字节数必须是4的倍数，不足补齐t
fout.open(TxtFilePath,ios::out);
for(i=m_sBMIH.biHeight-1;i>=0;i--)
{
fout<<"第"<<m_sBMIH.biHeight-i<<"行像素点的灰度值：\n";
for(j=0;j<m_sBMIH.biWidth;j++)
{
pt = m_pBData+i*(m_sBMIH.biWidth*3+t)+3*j ;
r = (int)(*pt);
g = (int)(*(pt+1));
b = (int)(*(pt+2));
// Gray = (r*0.299+g*0.587+b*0.114);
Gray = (r*38 + g*75 + b*15) >> 7;
fout<<setiosflags(ios::left)<<setw(4)<<Gray;
}
fout<<endl;
}
fout.close();
break;
case 32:
//每行字节数必是4的倍数，所以不用补齐
fout.open(TxtFilePath,ios::out);
for(i=m_sBMIH.biHeight-1;i>=0;i--)
{
fout<<"第"<<m_sBMIH.biHeight-i<<"行像素点的灰度值：\n";
for(j=0;j<m_sBMIH.biWidth;j++)
{
pt = m_pBData+i*(m_sBMIH.biWidth*4+t)+4*j ;
r = (int)(*pt);
g = (int)(*(pt+1));
b = (int)(*(pt+2));
// Gray = (r*0.299+g*0.587+b*0.114);
Gray = (r*38 + g*75 + b*15) >> 7;
fout<<setiosflags(ios::left)<<setw(4)<<Gray;
}
fout<<endl;
}
fout.close();
break;
default:
return false;
}
cout<<"灰度值记录在文件"<<TxtFilePath<<"中"<<endl;
delete [] TxtFilePath;
return true;
}

int main(int argc,char *argv[])
{
if(argc !=2 )
{
cout<<"输入参数错误，正确形式：\nyourprogram filePath"<<endl;
return 0;
}

CBmp Bitmap;
if( Bitmap.ReadInfo(argv[1]) )
Bitmap.WriteToTxt(argv[1]);
else
{
cout<<"读取文件出错"<<endl;
return 0;
}
return 1;
}

㈢ 如何用c语言（C++）读取位图的像素点RGB信息

pData里面保存的就是一个一个的COLORREF结构，你只需要通过BITMAPINFOHEADER中的宽高等信息，计算位移，就可以读取某个点的RGB值了。
还有一个简单的办法，你之前已经有memBitmap这个CBitmap了，通过这个做更方便。通过SelectObject将memBitmap放到一个CDC中，直接使用函数GetPixel函数就可以获取指定某个点的RGB值了，这个不需要计算和位移。

㈣ 如何用C语言程序从bmp格式的图片中读取图片的灰度值

1、首先要了解bmp位图的格式，搜索些技术支持文档，bmp位图基本上是分4大部分，文件信息结果部分，文件头信息结果部分，调色板结果部分，后面就是数据实体部分。及其每个部分对应有用的信息。比如长宽。当然长宽信息你自己可以从window系统下看得到。打开bmp文件，把前面三部分的字节总数给固定下来，逐个字符读取，然后读取数据实体部分，输出就可以了。
2、例程：

#include<stdio.h>
#include<stdlib.h>
#pragmapack(2)
/*定义WORD为两个字节的类型*/
typedefunsignedshortWORD;
/*定义DWORD为e四个字节的类型*/
typedefunsignedlongDWORD;
/*位图文件头*/
typedefstructBMP_FILE_HEADER
{
WORDbType;/*文件标识符*/
DWORDbSize;/*文件的大小*/
WORDbReserved1;/*保留值,必须设置为0*/
WORDbReserved2;/*保留值,必须设置为0*/
DWORDbOffset;/*文件头的最后到图像数据位开始的偏移量*/
}BMPFILEHEADER;
/*位图信息头*/
typedefstructBMP_INFO
{
DWORDbInfoSize;/*信息头的大小*/
DWORDbWidth;/*图像的宽度*/
DWORDbHeight;/*图像的高度*/
WORDbPlanes;/*图像的位面数*/
WORDbBitCount;/*每个像素的位数*/
DWORDbCompression;/*压缩类型*/
DWORDbmpImageSize;/*图像的大小,以字节为单位*/
DWORDbXPelsPerMeter;/*水平分辨率*/
DWORDbYPelsPerMeter;/*垂直分辨率*/
DWORDbClrUsed;/*使用的色彩数*/
DWORDbClrImportant;/*重要的颜色数*/
}BMPINF;
/*彩色表*/
typedefstructRGB_QUAD
{
WORDrgbBlue;/*蓝色强度*/
WORDrgbGreen;/*绿色强度*/
WORDrgbRed;/*红色强度*/
WORDrgbReversed;/*保留值*/
}RGBQUAD;
intmain()
{
FILE*fp;
BMPFILEHEADERfileHeader;
BMPINFinfoHeader;
longoffset,bmpImageSize,width,height,bytesPerPixel,size,bitCount;
//inti,j;
//unsignedchar**p;
WORDc;
if((fp=fopen("5.bmp","rb"))==NULL)
{
printf("Cann'topenthefile!
");
exit(0);
}
fseek(fp,0,0);
fread(&fileHeader,sizeof(fileHeader),1,fp);
fread(&infoHeader,sizeof(infoHeader),1,fp);
//计算并输出位图数据的偏移量，图像的大小，宽度和高度，每个像素点所占的字节
size=fileHeader.bSize;
offset=fileHeader.bOffset;
bmpImageSize=infoHeader.bmpImageSize;
width=infoHeader.bWidth;
height=infoHeader.bHeight;
bitCount=infoHeader.bBitCount;
bytesPerPixel=infoHeader.bBitCount/8;
printf("%d%d%d%d%d%d
",size,offset,bmpImageSize,width,height,bitCount,bytesPerPixel);
//输出每个像素点所占字节中的内容
c=fgetc(fp);
while(!feof(fp))
{
printf("%x",c);
c=fgetc(fp);
}
printf("
");
fclose(fp);
return0;
}

㈤ 如何用c语言printf输出bmp图片的像素信息。

#include<math.h>
#include<iomanip.h>
#include<stdlib.h>
#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<iostream.h>
#include<fstream.h>

//---------------------------------------------------------------------------------------
//以下该模块是完成BMP图像(彩色图像是24bitRGB各8bit)的像素获取，并存在文件名为xiang_su_.txt中
unsignedchar*pBmpBuf;//读入图像数据的指针

intbmpWidth;//图像的宽
intbmpHeight;//图像的高
RGBQUAD*pColorTable;//颜色表指针

intbiBitCount;//图像类型，每像素位数

//-------------------------------------------------------------------------------------------
//读图像的位图数据、宽、高、颜色表及每像素位数等数据进内存，存放在相应的全局变量中
boolreadBmp(char*bmpName)
{
FILE*fp=fopen(bmpName,"rb");//二进制读方式打开指定的图像文件

if(fp==0)
return0;

//跳过位图文件头结构BITMAPFILEHEADER

fseek(fp,sizeof(BITMAPFILEHEADER),0);

//定义位图信息头结构变量，读取位图信息头进内存，存放在变量head中

BITMAPINFOHEADERhead;

fread(&head,sizeof(BITMAPINFOHEADER),1,fp);//获取图像宽、高、每像素所占位数等信息

bmpWidth=head.biWidth;

bmpHeight=head.biHeight;

biBitCount=head.biBitCount;//定义变量，计算图像每行像素所占的字节数（必须是4的倍数）

intlineByte=(bmpWidth*biBitCount/8+3)/4*4;//灰度图像有颜色表，且颜色表表项为256

if(biBitCount==8)
{

//申请颜色表所需要的空间，读颜色表进内存

pColorTable=newRGBQUAD[256];

fread(pColorTable,sizeof(RGBQUAD),256,fp);

}

//申请位图数据所需要的空间，读位图数据进内存

pBmpBuf=newunsignedchar[lineByte*bmpHeight];

fread(pBmpBuf,1,lineByte*bmpHeight,fp);

fclose(fp);//关闭文件

return1;//读取文件成功
}

//-----------------------------------------------------------------------------------------
//给定一个图像位图数据、宽、高、颜色表指针及每像素所占的位数等信息,将其写到指定文件中
boolsaveBmp(char*bmpName,unsignedchar*imgBuf,intwidth,intheight,intbiBitCount,RGBQUAD*pColorTable)
{

//如果位图数据指针为0，则没有数据传入，函数返回

if(!imgBuf)
return0;

//颜色表大小，以字节为单位，灰度图像颜色表为1024字节，彩色图像颜色表大小为0

intcolorTablesize=0;

if(biBitCount==8)
colorTablesize=1024;

//待存储图像数据每行字节数为4的倍数

intlineByte=(width*biBitCount/8+3)/4*4;

//以二进制写的方式打开文件

FILE*fp=fopen(bmpName,"wb");

if(fp==0)
return0;

//申请位图文件头结构变量，填写文件头信息

BITMAPFILEHEADERfileHead;

fileHead.bfType=0x4D42;//bmp类型

//bfSize是图像文件4个组成部分之和

fileHead.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+colorTablesize+lineByte*height;

fileHead.bfReserved1=0;

fileHead.bfReserved2=0;

//bfOffBits是图像文件前3个部分所需空间之和

fileHead.bfOffBits=54+colorTablesize;

//写文件头进文件

fwrite(&fileHead,sizeof(BITMAPFILEHEADER),1,fp);

//申请位图信息头结构变量，填写信息头信息

BITMAPINFOHEADERhead;

head.biBitCount=biBitCount;

head.biClrImportant=0;

head.biClrUsed=0;

head.biCompression=0;

head.biHeight=height;

head.biPlanes=1;

head.biSize=40;

head.biSizeImage=lineByte*height;

head.biWidth=width;

head.biXPelsPerMeter=0;

head.biYPelsPerMeter=0;

//写位图信息头进内存

fwrite(&head,sizeof(BITMAPINFOHEADER),1,fp);

//如果灰度图像，有颜色表，写入文件

if(biBitCount==8)
fwrite(pColorTable,sizeof(RGBQUAD),256,fp);

//写位图数据进文件

fwrite(imgBuf,height*lineByte,1,fp);

//关闭文件

fclose(fp);

return1;

}

//----------------------------------------------------------------------------------------
//以下为像素的读取函数
voiddoIt()
{

//读入指定BMP文件进内存

charreadPath[]="nv.BMP";

readBmp(readPath);

//输出图像的信息

cout<<"width="<<bmpWidth<<"height="<<bmpHeight<<"biBitCount="<<biBitCount<<endl;

//循环变量，图像的坐标

//每行字节数

intlineByte=(bmpWidth*biBitCount/8+3)/4*4;

//循环变量，针对彩色图像，遍历每像素的三个分量

intm=0,n=0,count_xiang_su=0;

//将图像左下角1/4部分置成黑色

ofstreamoutfile("图像像素.txt",ios::in|ios::trunc);

if(biBitCount==8)//对于灰度图像
{
//------------------------------------------------------------------------------------
//以下完成图像的分割成8*8小单元，并把像素值存储到指定文本中。由于BMP图像的像素数据是从
//左下角：由左往右，由上往下逐行扫描的
intL1=0;
inthang=63;
intlie=0;
//intL2=0;
//intfen_ge=8;
for(intfen_ge_hang=0;fen_ge_hang<8;fen_ge_hang++)//64*64矩阵行循环
{
for(intfen_ge_lie=0;fen_ge_lie<8;fen_ge_lie++)//64*64列矩阵循环
{
//--------------------------------------------
for(L1=hang;L1>hang-8;L1--)//8*8矩阵行
{
for(intL2=lie;L2<lie+8;L2++)//8*8矩阵列
{
m=*(pBmpBuf+L1*lineByte+L2);
outfile<<m<<"";
count_xiang_su++;
if(count_xiang_su%8==0)//每8*8矩阵读入文本文件
{
outfile<<endl;
}
}
}
//---------------------------------------------
hang=63-fen_ge_hang*8;//64*64矩阵行变换
lie+=8;//64*64矩阵列变换
//该一行（64）由8个8*8矩阵的行组成
}
hang-=8;//64*64矩阵的列变换
lie=0;//64*64juzhen
}
}

//doublexiang_su[2048];
//ofstreamoutfile("xiang_su_.txt",ios::in|ios::trunc);
if(!outfile)
{
cout<<"openerror!"<<endl;
exit(1);
}
elseif(biBitCount==24)
{//彩色图像
for(inti=0;i<bmpHeight;i++)
{
for(intj=0;j<bmpWidth;j++)
{
for(intk=0;k<3;k++)//每像素RGB三个分量分别置0才变成黑色
{
//*(pBmpBuf+i*lineByte+j*3+k)-=40;
m=*(pBmpBuf+i*lineByte+j*3+k);
outfile<<m<<"";
count_xiang_su++;
if(count_xiang_su%8==0)
{
outfile<<endl;
}
//n++;
}
n++;
}


}
cout<<"总的像素个素为:"<<n<<endl;
cout<<"----------------------------------------------------"<<endl;
}

//将图像数据存盘

charwritePath[]="nvcpy.BMP";//图片处理后再存储

saveBmp(writePath,pBmpBuf,bmpWidth,bmpHeight,biBitCount,pColorTable);

//清除缓冲区，pBmpBuf和pColorTable是全局变量，在文件读入时申请的空间

delete[]pBmpBuf;

if(biBitCount==8)
delete[]pColorTable;
}

voidmain()
{
doIt();
}

㈥ C#中如何得到图片所有像素

步骤如下：
(1)在.NET中创建一个窗体，加入pictureBox控件。设置其Image为空，SizeMode属性设为AutoSize；
(2)加入一个OpenFileDialog控件，一个button控件，用于打开图片文件；
(3)加入三个textBox控件，用于表示RGB三个颜色的值。
(4)定义一个私有变量pick为布尔值，来表示是否拾取图片上的颜色。并在Form1_Load中将其设置为false；再加入一个public Bitmap myBitmap用来进行函间的访问。
(5)为button控件增加click事件，该事件主要是完成读入文件和对pictureBox控件的初始化：
(6)为pictureBox控件增加mousemove事件：
代码如下：
Step1：设置bool值pick并初始化几个变量
public bool pick;
public Bitmap myBitmap;
private void Form1_Load(object sender, EventArgs e)
{
pick = false;
}

㈦ c语言数字图像处理怎么显示一张照片的像素值

#include <stdio.h>
#include <windows.h>
int main()
{
//变量
char title[255];//用于存放控制台窗口标题
HWND hwnd;//窗口的句柄，H：Handle
HDC hdc, hmemdc;//设备上下文句柄，DC：driver context
HBITMAP hbm;//图片的句柄
BITMAP bm;//图片结构体
RECT rect;//矩形 rectangle
//把控制台窗口调成100字符宽度，40行
system("mode con cols=100 lines=40");

//1.取得窗口的句柄
GetConsoleTitleA(title, 255);//获取控制台窗口的标题
hwnd = FindWindowA(NULL, title);//通过窗口标题取得该窗口的句柄
//获取窗口的高度和宽度
GetWindowRect(hwnd, &rect);
//2. 获取画笔
hdc = GetDC(hwnd);
/* if(!hdc)
printf("No val\n");
else
printf("have\n");
TextOutA(hdc, 300, 400, "Hello world", strlen("Hello world"));*/
hmemdc = CreateCompatibleDC(hdc);//创建一个兼容的DC
//3.加载图片
hbm = (HBITMAP)LoadImageA(NULL, "123.bmp", IMAGE_BITMAP, 0, 0,
LR_LOADFROMFILE);
GetObject(hbm, sizeof(BITMAP), &bm);//得到图片信息
//4.把图片放入兼容DC中
SelectObject(hmemdc, hbm);

//5.在窗口上画出图片
BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hmemdc, 0, 0, SRCCOPY);

DeleteObject(hbm);
DeleteObject(hmemdc);
ReleaseDC(hwnd, hdc);
return 0;
}

㈧ 用C语言读取16位bmp图片的每个像素的信息~

没有什么不同。
读出 BITMAPINFO 结构：
typedef struct tagBITMAPINFO {
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[1];
} BITMAPINFO;
以后，

BITMAPINFOHEADER 结构 里就有 biBitCount
biBitCount 等于 16 就是16位，等于24 就是24位，等于32 就是32位。

颜色在哪，要考虑 biCompression 压缩方法，若等于 BI_RGB, bmiColors 就等于 NULL. 在 bitmap 数组里 每个WORD 就是 一个像素点. 5个 bits 兰，5个 bits 绿，再5个 bits 红，最高位不用。
其它方法自己看资料吧。

㈨ 怎样用C语言得到jpeg格式或BMP格式的图像的像素的rgb值

原型：
int WINAPI icePub_getImgfilePColor(char *strImgFilename,int x,int y,char *strR,char *strG,char *strB,int flag)
输入：strImgFilename 待处理的图片文件名
x x坐标
y y坐标
flag 输出RGB值的格式，0 10进制,1 16进制
输出：strR R值
strG G值
strB B值
返回码：0 OK;-2 x,y值超出图片长宽

int retCode=-1;
char strR[128],strG[128],strB[128];
Cstring m_mem;

typedef int (WINAPI ICEPUB_GETIMGFILEPCOLOR)(char *strImgFilename,int x,int y,char *strR,char *strG,char *strB,int flag);
ICEPUB_GETIMGFILEPCOLOR *icePub_getImgfilePColor = 0;
HINSTANCE hDLLDrv = LoadLibrary("icePubDll.dll");
if(hDLLDrv)
icePub_getImgfilePColor = (ICEPUB_GETIMGFILEPCOLOR *)GetProcAddress(hDLLDrv, "icePub_getImgfilePColor");
if(icePub_getImgfilePColor)
retCode=icePub_getImgfilePColor("a.jpg",100,55,strR,strG,strB,0);
if(hDLLDrv)
FreeLibrary(hDLLDrv);
if(retCode == 0)
m_mem.Format("(x,y):%d,%d\r\nR:%s\r\nG:%s\r\nB:%s",point.x,point.y,strR,strG,strB);
AfxMessageBox(m_mem);

原型：
int WINAPI icePub_imgToFileTextdata(char *strImgFilename,char *strFilename,char *strFenge,int flag)
输入：strImgFilename 待处理图像文件 (会被强制256级灰度化)
strFilename 待生成BMP文本数据文件名
strFenge 列之间分隔符
flag 文本数据格式标志：0 10进制; 1 16进制; 10 RGB16进制
输出：

extern "C"
{
__declspec(dllexport)
int WINAPI icePub_imgToFileTextdata(char *strImgFilename,char *strFilename,char *strFenge,int flag);
}

#pragma comment(lib,"icePubDll.lib")

icePub_imgToFileTextdata("a.jpg","bmpdata.txt",",",0);

原型：
char * WINAPI icePub_getBufferFromImg2(char *strImgFilename,int *width,int *height,int huiGrade)
输入：strImgFilename 图片文件名
huiGrade 图像灰度化标志，0 no; >1 and <=256 灰度级
输出：width 图像宽度
height 图像高度
返回值：图像的点阵数据(按照24位BMP格式)

extern "C"
{
__declspec(dllexport)
char * WINAPI icePub_getBufferFromImg2(char *strImgFilename,int *width,int *height,int huiGrade);
}

#pragma comment(lib,"icePubDll.lib")

char *bmpBuffer=NULL;
int imgWidth, imgHeight;

bmpBuffer = icePub_getBufferFromImg2 ("e:\\a.jpg",&imgWidth,&imgHeight,0);
//然后对bmpBuffer数据处理即可

if(bmpBuffer != NULL)
free(bmpBuffer);