‘壹’ 求soble算子和prewitt算子源代码，用c语言编的！用于数字图像处理！
自己以前图像处理的时候写的,用的是C++, 不过处理流程一样的,可以参考一下
//Soble
void CBmp::RhSobel()
{
double temp[9];
DWORD m_Y=m_pInfo->bmiHeader.biHeight;
DWORD m_X=WIDTH((m_pInfo->bmiHeader.biWidth)*(m_pInfo->bmiHeader.biBitCount));
BYTE *m_B=(BYTE *) new char[m_Y*m_X];
for(int d=0;d<m_nPixels;d++)
{
m_B[d]=m_pPixels[d];
}
if((m_pInfo->bmiHeader.biBitCount)==24)
for(int i=1;i<m_Y-1;i++)
for(int j=3;j<(m_X-2);j+=3)
{
for(int n=0;n<9;n+=3)
{
temp[n]=(m_B[(i-1+n/3)*m_X+j-3]+m_B[(i-1+n/3)*m_X+j-2]+m_B[(i-1+n/3)*m_X+j-1])/3;
temp[n+1]=(m_B[(i-1+n/3)*m_X+j]+m_B[(i-1+n/3)*m_X+j+1]+m_B[(i-1+n/3)*m_X+j+2])/3;
temp[n+2]=(m_B[(i-1+n/3)*m_X+j+3]+m_B[(i-1+n/3)*m_X+j+4]+m_B[(i-1+n/3)*m_X+j+5])/3;
}
m_pPixels[i*m_X+j]=m_pPixels[i*m_X+j+1]=m_pPixels[i*m_X+j+2]=//
(BYTE((abs(temp[2]+2*temp[5]+temp[8]-//
temp[0]-2*temp[3]-temp[6])+
abs(temp[0]+2*temp[1]+temp[2]-//
temp[6]-2*temp[7]-temp[8]))));
}
else
for(int i=1;i<(m_Y-1);i++)
{
for(int j=1;j<(m_X-1);j++)
{
m_pPixels[i*m_X+j]=(abs(m_B[(i-1)*m_X+j+1]+(2*m_B[(i)*m_X+j+1])+m_B[(i+1)*m_X+j+1]-//
m_B[(i-1)*m_X+j-1]-(2*m_B[(i)*m_X+j-1])-m_B[(i+1)*m_X+j-1])+
abs(m_B[(i-1)*m_X+j-1]+(2*m_B[(i-1)*m_X+j])+m_B[(i-1)*m_X+j+1]-//
m_B[(i+1)*m_X+j-1]-(2*m_B[(i+1)*m_X+j])-m_B[(i+1)*m_X+j+1]));
}
}
}
//Prewitt
void CBmp::ByPrewitt()
{
double temp1,temp2;
DWORD m_Y=m_pInfo->bmiHeader.biHeight;
DWORD m_X=WIDTH((m_pInfo->bmiHeader.biWidth)*(m_pInfo->bmiHeader.biBitCount));
BYTE *m_B=(BYTE *) new char[m_Y*m_X];
for(int d=0;d<m_nPixels;d++)
{
m_B[d]=m_pPixels[d];
}
if(m_pInfo->bmiHeader.biBitCount==8)
for(int i=1;i<(m_Y-1);i++)
{
for(int j=1;j<(m_X-1);j++)
{
temp1=abs(m_B[(i-1)*m_X+j+1]-m_B[(i-1)*m_X+j-1]+m_B[i*m_X+j+1]-//
m_B[i*m_X+j-1]+m_B[(i+1)*m_X+j+1]-m_B[(i+1)*m_X+j-1]);
temp2=abs(m_B[(i-1)*m_X+j-1]+m_B[(i-1)*m_X+j]+m_B[(i-1)*m_X+j+1]-//
m_B[(i+1)*m_X+j-1]-m_B[(i+1)*m_X+j]-m_B[(i+1)*m_X+j+1]);
m_pPixels[i*m_X+j]=(temp1>temp2?temp1:temp2);
}
}
else
{
Hui();
for(int i=1;i<(m_Y-1);i++)
{
for(int j=3;j<(m_X-5);j+=3)
{
temp1=abs(m_B[(i-1)*m_X+j+3]-m_B[(i-1)*m_X+j-3]+m_B[i*m_X+j+3]-//
m_B[i*m_X+j-3]+m_B[(i+1)*m_X+j+3]-m_B[(i+1)*m_X+j-3]);
temp2=abs(m_B[(i-1)*m_X+j-3]+m_B[(i-1)*m_X+j]+m_B[(i-1)*m_X+j+3]-//
m_B[(i+1)*m_X+j-3]-m_B[(i+1)*m_X+j]-m_B[(i+1)*m_X+j+3]);
m_pPixels[i*m_X+j]=m_pPixels[i*m_X+j+1]=m_pPixels[i*m_X+j+2]=(temp1>temp2?temp1:temp2);
}
}
}
}
‘贰’ 用c语言求圆的面积
用c语言求圆的面积编程如下：
#include <stdio.h>
#include <math.h>
#define PI 3.14
void main()
{ float r;
double c;
double s;
printf("请输入半径的值:");
scanf("%f",&r);
s=PI*r*r;
printf("这个圆的面积是：%f ",s);
(2)roberts算子c语言扩展阅读：
使用c语言的优点
1、简洁紧凑、灵活方便
C语言一共只有32个关键字，9种控制语句，程序书写形式自由，区分大小写。把高级语言的基本结构和语句与低级语言的实用性结合起来。C 语言可以像汇编语言一样对位、字节和地址进行操作，而这三者是计算机最基本的工作单元。
2、运算符丰富
C语言的运算符包含的范围很广泛，共有34种运算符。C语言把括号、赋值、强制类型转换等都作为运算符处理。从而使C语言的运算类型极其丰富，表达式类型多样化。灵活使用各种运算符可以实现在其它高级语言中难以实现的运算。
3、数据类型丰富
C语言的数据类型有：整型、实型、字符型、数组类型、指针类型、结构体类型、共用体类型等。能用来实现各种复杂的数据结构的运算。并引入了指针概念，使程序效率更高。
4、表达方式灵活实用
C语言提供多种运算符和表达式值的方法，对问题的表达可通过多种途径获得，其程序设计更主动、灵活。它语法限制不太严格，程序设计自由度大，如对整型量与字符型数据及逻辑型数据可以通用等。
5、允许直接访问物理地址，对硬件进行操作
由于C语言允许直接访问物理地址，可以直接对硬件进行操作，因此它既具有高级语言的功能，又具有低级语言的许多功能，能够像汇编语言一样对位（bit）、字节和地址进行操作，而这三者是计算机最基本的工作单元，可用来写系统软件。
6、生成目标代码质量高，程序执行效率高
C语言描述问题比汇编语言迅速，工作量小、可读性好，易于调试、修改和移植，而代码质量与汇编语言相当。C语言一般只比汇编程序生成的目标代码效率低10%～20%。
7、可移植性好
C语言在不同机器上的C编译程序，86%的代码是公共的，所以C语言的编译程序便于移植。在一个环境上用C语言编写的程序，不改动或稍加改动，就可移植到另一个完全不同的环境中运行。
8、表达力强
C语言有丰富的数据结构和运算符。包含了各种数据结构，如整型、数组类型、指针类型和联合类型等，用来实现各种数据结构的运算。C语言的运算符有34种，范围很宽，灵活使用各种运算符可以实现难度极大的运算。
C语言能直接访问硬件的物理地址，能进行位（bit）操作。兼有高级语言和低级语言的许多优点。
它既可用来编写系统软件，又可用来开发应用软件，已成为一种通用程序设计语言。
另外C语言具有强大的图形功能，支持多种显示器和驱动器。且计算功能、逻辑判断功能强大。
‘叁’ C语言入门知识
char a[20],b[20],c[20];上面的a,b,c都是数组变量,在定义时已经为其分配栈内存,而char (*str1)[20],(*str2)[20],(*str3)[20]; 只是分配了4个字节的内存来保存指针变量(即变量本身),而指针的值(即指向)还没有,所以这些指针还不能保存数据!--------------char (*str1)[20],(*str2)[20],(*str3)[20]; str1 str2 str3均为指针,都指向长度为20的char数组.你只定义了指针,但是没有对其进
‘肆’ 能否编写一个用matlab实现的基于Roberts算子的图像边缘检测程序
clear; fid=fopen('d:\image\Lena.img','r'); %打开无格式文件 data1=(fread(fid,[256,256],'uint8'))'; subplot(2,3,1),imagesc(data1); colormap(gray); title('LENA','Color','r'); subplot(2,3,2); data2=uint8(data1); R=edge(data2,'Roberts'); imagesc(R); title('Roberts检测算子'); subplot(2,3,3); data2=uint8(data1); Q=edge(data2,'Prewitt'); imagesc(Q); title('Prewitt检测算子'); subplot(2,3,4); data2=uint8(data1); S=edge(data2,'Sobel'); imagesc(S); title('Sobel检测算子'); subplot(2,3,5); data2=uint8(data1); T=edge(data2,'Log'); imagesc(T); title('Log检测算子'); Matlab中运行过的 正确的！
‘伍’ Matlab关于图像边缘提取，用Sobel算子、Roberts算子、Prewitt算子，加QQ详谈 急用！！
4.2.1 Roberts算法原理
Roberts算子是一种最简单的算子，是一种利用局部差分算子寻找边缘的算子，他采用对角线方向相邻两象素之差近似梯度幅值检测边缘。检测垂直边缘的效果好于斜向边缘，定位精度高，对噪声敏感,无法抑制噪声的影响。
4.2.2 算法流程
Roberts算子在2×2领域上计算对角导数
（4-1）
成为Roberts交叉算子。在实际应用中为了简化计算，用梯度函数的Roberts绝对值来近似
（4-2）另外还可以用Roberts 最大算子来计算
（4-3）
上式能够提供较好的不变性边缘取向。对于同等长度但取向不同的边缘，应用Roberts最大值算子比应用Roberts交叉算子所得到的合成幅度变化小。Roberts边缘检测算子的卷积算子为
Roberts 边缘算子方向模版
由上面两个卷积算子对图像运算后，代入（3-7）式，可求得图像的梯度幅度值，然后选取门限TH，做如下判断>TH，为阶跃状边缘点为一个二值图像，也就是图像的边缘图像。4.4.1 Prewitt 算法原理
Prewitt边缘算子是一种边缘样板算子。Prewitt 从加大边缘检测算子的模板大小出发，由2×2 扩大到3×3 来计算差分算子，采用Prewitt 算子不仅能检测边缘点，而且能抑制噪声的影响。
Prewitt 采用计算偏微分估计的方法，由式（4-9）所示的两个卷积算子形成了Prewitt边缘算子，样板算子由理想的边缘子图像构成，依次用边缘样板去检测图像，与被检测区域最为相似的样板给出最大值，用这个最大值作为算子的输出
（4-9）
另一种方法是，可以将Prewitt算子扩展到八个方向，每个模版对特定的边缘方向做出最大响应，所有8个方向中最大值作为边缘幅度图像的输出，这些算子样板由离线的边缘子图像构成。依次用边缘样板去检测图像，与被检测区域最为相似的的样板给出最大值。定义Prewitt 边缘检测的算子模版如下：
（1）1方向 （2）2方向 （3）3方向 （4）4方
‘陆’ vc图像处理Robert算子源代码有点看不懂，请教高手帮我解答一下
/*
FILE: edgeSob.c - WORKS!!
AUTH: Bill Green
DESC: 2 3x3 Sobel masks for edge detection
DATE: 07/23/02
REFS: edgeLap.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <alloc.h>
/*-------STRUCTURES---------*/
typedef struct sImage;
/*-------PROTOTYPES---------*/
long getImageInfo(FILE*, long, int);
void ImageInfo(FILE* inputFile, FILE* outputFile);
void ColorTable(FILE* inputFile, FILE* outputFile, int nColors);
int main(int argc, char* argv[])
{
FILE *bmpInput, *bmpOutput;
sImage originalImage;
sImage edgeImage;
unsigned int X, Y;
int I, J;
long sumX, sumY;
int nColors, SUM;
unsigned long vectorSize;
unsigned long fileSize;
int GX[3][3];
int GY[3][3];
unsigned char *pChar, someChar;
unsigned int row, col;
someChar = '0'; pChar = &someChar;
/* 3x3 GX Sobel mask. Ref: */
GX[0][0] = -1; GX[0][1] = 0; GX[0][2] = 1;
GX[1][0] = -2; GX[1][1] = 0; GX[1][2] = 2;
GX[2][0] = -1; GX[2][1] = 0; GX[2][2] = 1;
/* 3x3 GY Sobel mask. Ref: */
GY[0][0] = 1; GY[0][1] = 2; GY[0][2] = 1;
GY[1][0] = 0; GY[1][1] = 0; GY[1][2] = 0;
GY[2][0] = -1; GY[2][1] = -2; GY[2][2] = -1;
if(argc < 2) {
printf("Usage: %s bmpInput.bmp\n", argv[0]);
exit(0);
};
printf("Reading filename %s\n", argv[1]);
/*-------DECLARE INPUT & OUTPUT FILES-------*/
bmpInput = fopen(argv[1], "rb");
bmpOutput = fopen("edgeSob.bmp", "wb");
/*---SET POINTER TO BEGINNING OF FILE----*/
fseek(bmpInput, 0L, SEEK_END);
/*-------GET INPUT BMP DATA--------*/
fileSize = getImageInfo(bmpInput, 2, 4);
originalImage.cols = (int)getImageInfo(bmpInput, 18, 4);
originalImage.rows = (int)getImageInfo(bmpInput, 22, 4);
edgeImage.rows = originalImage.rows;
edgeImage.cols = originalImage.cols;
/*--------PRINT DATA TO SCREEN----------*/
printf("Width: %d\n", originalImage.cols);
printf("Height: %d\n", originalImage.rows);
printf("File size: %lu\n", fileSize);
nColors = (int)getImageInfo(bmpInput, 46, 4);
printf("nColors: %d\n", nColors);
/*------ALLOCATE MEMORY FOR FILES--------*/
vectorSize = fileSize - (14+40+4*nColors);
printf("vectorSize: %lu\n", vectorSize);
edgeImage.data = farmalloc(vectorSize*sizeof(unsigned char));
if(edgeImage.data == NULL) {
printf("Failed to malloc edgeImage.data\n");
exit(0);
}
printf("%lu bytes malloc'ed for edgeImage.data\n", vectorSize);
originalImage.data = farmalloc(vectorSize*sizeof(unsigned char));
if(originalImage.data == NULL) {
printf("Failed to malloc originalImage.data\n");
exit(0);
}
printf("%lu bytes malloc'ed for originalImage.datt\n", vectorSize);
/*------COPY HEADER AND COLOR TABLE---------*/
ImageInfo(bmpInput, bmpOutput);
ColorTable(bmpInput, bmpOutput, nColors);
fseek(bmpInput, (14+40+4*nColors), SEEK_SET);
fseek(bmpOutput, (14+40+4*nColors), SEEK_SET);
/* Read input.bmp and store it's raster data into originalImage.data */
for(row=0; row<=originalImage.rows-1; row++) {
for(col=0; col<=originalImage.cols-1; col++) {
fread(pChar, sizeof(char), 1, bmpInput);
*(originalImage.data + row*originalImage.cols + col) = *pChar;
}
}
/*---------------------------------------------------
SOBEL ALGORITHM STARTS HERE
---------------------------------------------------*/
for(Y=0; Y<=(originalImage.rows-1); Y++) {
for(X=0; X<=(originalImage.cols-1); X++) {
sumX = 0;
sumY = 0;
/* image boundaries */
if(Y==0 || Y==originalImage.rows-1)
SUM = 0;
else if(X==0 || X==originalImage.cols-1)
SUM = 0;
/* Convolution starts here */
else {
/*-------X GRADIENT APPROXIMATION------*/
for(I=-1; I<=1; I++) {
for(J=-1; J<=1; J++) {
sumX = sumX + (int)( (*(originalImage.data + X + I + (Y + J)*originalImage.cols)) * GX[I+1][J+1]);
}
}
if(sumX>255) sumX=255;
if(sumX<0) sumX=0;
/*-------Y GRADIENT APPROXIMATION-------*/
for(I=-1; I<=1; I++) {
for(J=-1; J<=1; J++) {
sumY = sumY + (int)( (*(originalImage.data + X + I + (Y + J)*originalImage.cols)) * GY[I+1][J+1]);
}
}
if(sumY>255) sumY=255;
if(sumY<0) sumY=0;
SUM = abs(sumX) + abs(sumY); /*---GRADIENT MAGNITUDE APPROXIMATION (Myler p.218)----*/
}
*(edgeImage.data + X + Y*originalImage.cols) = 255 - (unsigned char)(SUM); /* make edges black and background white */
fwrite( (edgeImage.data + X + Y*originalImage.cols), sizeof(char), 1, bmpOutput);
}
}
printf("See edgeSob.bmp for results\n");
fclose(bmpInput);
fclose(bmpOutput);
farfree(edgeImage.data); /* Finished with edgeImage.data */
farfree(originalImage.data); /* Finished with originalImage.data */
return 0;
}
/*----------GET IMAGE INFO SUBPROGRAM--------------*/
long getImageInfo(FILE* inputFile, long offset, int numberOfChars)
{
unsigned char *ptrC;
long value = 0L;
unsigned char mmy;
int i;
mmy = '0';
ptrC = &mmy;
fseek(inputFile, offset, SEEK_SET);
for(i=1; i<=numberOfChars; i++)
{
fread(ptrC, sizeof(char), 1, inputFile);
/* calculate value based on adding bytes */
value = (long)(value + (*ptrC)*(pow(256, (i-1))));
}
return(value);
} /* end of getImageInfo */
/*-------------COPIES HEADER AND INFO HEADER----------------*/
void ImageInfo(FILE* inputFile, FILE* outputFile)
{
unsigned char *ptrC;
unsigned char mmy;
int i;
mmy = '0';
ptrC = &mmy;
fseek(inputFile, 0L, SEEK_SET);
fseek(outputFile, 0L, SEEK_SET);
for(i=0; i<=50; i++)
{
fread(ptrC, sizeof(char), 1, inputFile);
fwrite(ptrC, sizeof(char), 1, outputFile);
}
}
/*----------------COPIES COLOR TABLE-----------------------------*/
void ColorTable(FILE* inputFile, FILE* outputFile, int nColors)
{
unsigned char *ptrC;
unsigned char mmy;
int i;
mmy = '0';
ptrC = &mmy;
fseek(inputFile, 54L, SEEK_SET);
fseek(outputFile, 54L, SEEK_SET);
for(i=0; i<=(4*nColors); i++) /* there are (4*nColors) bytesin color table */
{
fread(ptrC, sizeof(char), 1, inputFile);
fwrite(ptrC, sizeof(char), 1, outputFile);
}
}
‘柒’ 用Sobel算子、Roberts算子、Prewitt算子对图像进行边缘检测的程序，在matlab环境下，程序要完整，最好有图
closeall
clearall
I=imread('tig.jpg');%读取图像
I1=im2double(I);%将彩图序列变成双精度
I2=rgb2gray(I1);%将彩色图变成灰色图
[thr,sorh,keepapp]=ddencmp('den','wv',I2);
I3=wdencmp('gbl',I2,'sym4',2,thr,sorh,keepapp);%小波除噪
I4=medfilt2(I3,[99]);%中值滤波
I5=imresize(I4,0.2,'bicubic');%图像大小
BW1=edge(I5,'sobel');%sobel图像边缘提取
BW2=edge(I5,'roberts');%roberts图像边缘提取
BW3=edge(I5,'prewitt');%prewitt图像边缘提取
BW4=edge(I5,'log');%log图像边缘提取
BW5=edge(I5,'canny');%canny图像边缘提取
h=fspecial('gaussian',5);%高斯滤波
BW6=edge(I5,'zerocross',[],h);%zerocross图像边缘提取
figure;
subplot(1,3,1);%图划分为一行三幅图，第一幅图
imshow(I2);%绘图
figure;
subplot(1,3,1);
imshow(BW1);
title('Sobel算子');
subplot(1,3,2);
imshow(BW2);
title('Roberts算子');
subplot(1,3,3);
imshow(BW3);
title('Prewitt算子');
‘捌’ 求用C语言用Sobels算子方法编写图像边缘提取的程序算法！（急）
定义：每个像素的取值均为0或1，称这样的图像为二值图像。
算法：检查所有像素，若该像素为物体上与背景接触的像素（四连通像素中既有背景像素又有物体像素），则为边界。
程序：
#define M 30
#define N 20
void edge(int image[M][N],int bianyuan[M][N])
{
int i,j;
int inner=1,outer=1;
for (i=0;i<M;i++)/*清除数据*/
for(j=0;j<N;j++)
bianyuan[i][j]=0;
for(i=1;i<M-1;i++)
for(j=1;j<N-1;j++)
{
inner=1;/*假设该像素或为物体,或为背景*/
outer=1;
if(image[i-1][j]==0||image[i+1][j]==0||image[i][j-1]==0||image[i][j+1]==0)
inner=0;
if(image[i-1][j]==1||image[i+1][j]==1||image[i][j-1]==1||image[i][j+1]==1)
outer=0;
if(inner==0&&outer==0&&image[i][j]==1)/*像素周围既有物体又有背景*/ bianyuan[i][j]=1;/*,且该像素为物体上的像素(image[i][j]==1)，则定义为边界*/
}
}
void output(int array[M][N],int n)
{
int i,j;
for(i=0;i<n;i++)
{
printf("\n");
for(j=0;j<N;j++)
if(array[i][j]==1)
printf("1");
else
printf(" ");
}
}
void main()
{
int image[M][N]={{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,0,0},
{0,1,1,1,1,0,0,1,1,1,1,1,1,0,0,1,1,1,0},
{0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,1,1,1,0},
{0,0,1,1,1,1,0,0,0,1,1,1,1,1,0,1,1,1,0},
{0,1,1,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,0},
{0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
{0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0},
{0,0,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,0},
{0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0}};
int bianyuan[M][N]={0};
int i,j;
printf("\nThe origianl image is:\n");
output(image,10);
edge(image,bianyuan);
printf("\nIts edge is:\n");
output(bianyuan,10);
}
写完了，又看一下，感觉edge函数太罗嗦了，不够简练，想了一下，改成了下面的样子，函数接口不变：
void edge(int image[M][N],int bianyuan[M][N])
{
int i,j;
for (i=0;i<M;i++)
for(j=0;j<N;j++)
bianyuan[i][j]=0;
for(i=1;i<M-1;i++)
for(j=1;j<N-1;j++)
{
int t=image[i-1][j]+image[i+1][j]+image[i][j-1]+image[i][j+1];
if(t>0&&t<4&&image[i][j]==1)/*周围4个像素值介于1~3之间，*/
bianyuan[i][j]=1; /*且当前像素为物体，则其必为边界*/
}
}
希望这段代码对你有所帮助
‘玖’ 在C或C++环境下，分别利用sobel算子，robert算子，编程输出边缘图像。选错课了..完全不懂 求高手代码..
俺就给你写个sobel的，你把sobel模板换成robert模板就OK了。
本来sobel找阈值还有个小算法，不过一般不要求的，俺就用黄金分割点乘以255替代了。
sobel卷积代码如下：
voidCSobelDlg::CreateSobolImage(void)
{
staticconstintsizeOfSobelMask=9;
staticintsobelMaskHor[sizeOfSobelMask]=
{
-1,-2,-1,
0,0,0,
1,2,1
};
staticintSobelMaskVer[sizeOfSobelMask]=
{
1,0,-1,
2,0,-2,
1,0,1
};
intnumOfBytes=m_bmpInfo.bmWidthBytes*m_bmpInfo.bmHeight;
unsignedchar*pbuf1=newunsignedchar[numOfBytes];
unsignedchar*pbuf2=newunsignedchar[numOfBytes];
m_bmpOrg.GetBitmapBits(numOfBytes,pbuf1);
unsignedcharaverageColor=0;
for(introw=0;row<m_bmpInfo.bmHeight;++row)
{
for(intcol=0;col<m_bmpInfo.bmWidth;++col)
{
averageColor=(pbuf1[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+0]+
pbuf1[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+1]+
pbuf1[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+2])/3;
pbuf1[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+0]=averageColor;
}
}
unsignedcharts=0,tv=0,tmp=0,dst=0,idx=0;
for(introw=1;row<m_bmpInfo.bmHeight-1;++row)
{
for(intcol=1;col<m_bmpInfo.bmWidth-1;++col)
{
idx=ts=tv=0;
for(intr=row-1;r<=row+1;++r)
{
for(intc=col-1;c<=col+1;++c)
{
tmp=pbuf1[r*m_bmpInfo.bmWidthBytes+c*m_bmpInfo.bmBitsPixel/8];
ts+=(sobelMaskHor[idx]*tmp);
tv+=(SobelMaskVer[idx]*tmp);
++idx;
}
}
dst=(unsignedchar)sqrt((float)(ts*ts+tv*tv));
if(dst>(unsignedchar)(0.6180339887*255.0)){
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+0]=0;
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+1]=255;
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+2]=0;
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+3]=255;
}
else{
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+0]=0;
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+1]=0;
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+2]=255;
pbuf2[row*m_bmpInfo.bmWidthBytes+col*m_bmpInfo.bmBitsPixel/8+3]=255;
}
}
}
m_bmpSobol.CreateBitmap(m_bmpInfo.bmWidth,m_bmpInfo.bmHeight,1,32,pbuf2);
delete[]pbuf1;
delete[]pbuf2;
}
再给你一张本程序运行的效果图。
‘拾’ 图像提取C语言程序
抄来给你：
/// 按 Roberts 算子进行边缘检测
///
/// 位图流
///
public Bitmap Roberts(Bitmap b)
{
int width = b.Width;
int height = b.Height;
Bitmap dstImage = new Bitmap(width, height);
BitmapData srcData = b.LockBits(new Rectangle(0, 0, width, height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
BitmapData dstData = dstImage.LockBits(new Rectangle(0, 0, width, height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
int stride = srcData.Stride;
int offset = stride - width * BPP;
unsafe
{
byte* src = (byte*)srcData.Scan0;
byte* dst = (byte*)dstData.Scan0;
int A, B; // A(x-1, y-1) B(x, y-1)
int C, D; // C(x-1, y) D(x, y)
// 指向第一行
src += stride;
dst += stride;
// 不处理最上边和最左边
for (int y = 1; y < height; y++)
{
// 指向每行第一列
src += BPP;
dst += BPP;
for (int x = 1; x < width; x++)
{
for (int i = 0; i < 3; i++)
{
A = src[i - stride - BPP];
B = src[i - stride];
C = src[i - BPP];
D = src[i];
dst[i] = (byte)(Math.Sqrt((A - D) * (A - D) + (B - C) * (B - C)));
} // i
dst[3] = src[3];
src += BPP;
dst += BPP;
} // x
src += offset;
dst += offset;
} // y
}
b.UnlockBits(srcData);
dstImage.UnlockBits(dstData);
b.Dispose();
return dstImage;
} // end of Roberts
/// 边缘增强
///
/// 位图流
/// 阈值
///
public Bitmap EdgeEnhance(Bitmap b, int threshold)
{
int width = b.Width;
int height = b.Height;
Bitmap dstImage = (Bitmap)b.Clone();
BitmapData srcData = b.LockBits(new Rectangle(0, 0, width, height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
BitmapData dstData = dstImage.LockBits(new Rectangle(0, 0, width, height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
// 图像实际处理区域
// 不考虑最左 1 列和最右 1 列
// 不考虑最上 1 行和最下 1 行
int rectTop = 1;
int rectBottom = height - 1;
int rectLeft = 1;
int rectRight = width - 1;
unsafe
{
byte* src = (byte*)srcData.Scan0;
byte* dst = (byte*)dstData.Scan0;
int stride = srcData.Stride;
int offset = stride - width * BPP;
int pixel = 0;
int maxPixel = 0;
// 指向第 1 行
src += stride;
dst += stride;
for (int y = rectTop; y < rectBottom; y++)
{
// 指向每行第 1 列像素
src += BPP;
dst += BPP;
for (int x = rectLeft; x < rectRight; x++)
{
// Alpha
dst[3] = src[3];
// 处理 B, G, R 三分量
for (int i = 0; i < 3; i++)
{
// 右上-左下
maxPixel = src[i - stride + BPP] - src[i + stride - BPP];
if (maxPixel < 0) maxPixel = -maxPixel;
// 左上-右下
pixel = src[i - stride - BPP] - src[i + stride + BPP];
if (pixel < 0) pixel = -pixel;
if (pixel > maxPixel) maxPixel = pixel;
// 上-下
pixel = src[i - stride] - src[i + stride];
if (pixel < 0) pixel = -pixel;
if (pixel > maxPixel) maxPixel = pixel;
// 左-右
pixel = src[i - BPP] - src[i + BPP];
if (pixel < 0) pixel = -pixel;
if (pixel > maxPixel) maxPixel = pixel;
// 进行阈值判断
if (maxPixel < threshold) maxPixel = 0;
dst[i] = (byte)maxPixel;
}
// 向后移一像素
src += BPP;
dst += BPP;
} // x
// 移向下一行
// 这里得注意要多移 1 列，因最右边还有 1 列不必处理
src += offset + BPP;
dst += offset + BPP;
} // y
}
// b.UnlockBits(srcData);
dstImage.UnlockBits(dstData);
b.Dispose();
return dstImage;
} // end of EdgeEnhance
}