数字图像处理-编程实现染色体计数 C语言实现

最新推荐文章于 2024-07-21 17:28:08 发布
最新推荐文章于 2024-07-21 17:28:08 发布
阅读量1.6k 收藏 4
点赞数 1
分类专栏： 图像处理 C++ 文章标签： C 语言 图像处理

调用的框架：http://blog.chinaunix.net/uid-20622737-id-3173056.html 
实验内容： 
对于下面这幅图像，编程实现染色体计数，并附简要处理流程说明。 
这里写图片描述 
处理步骤： 
1. 读取图像，转换为灰度图像

  1. 平滑滤波去噪

  2. 图像二值化

  3. 对图像进行膨胀

  4. 再次膨胀(视情况而定)

  5. 腐蚀（视情况而定）

  6. 反转

  7. 统计连通区域个数并输出

  8. 保存图像。

void main()
{
    Bitmap *bmp = (Bitmap *)malloc(sizeof(Bitmap));// build an empty bmp to put the img.空变量呈放图片
    Bitmap *dstBmp = (Bitmap *)malloc(sizeof(Bitmap));
    Bitmap *graybmp = (Bitmap *)malloc(sizeof(Bitmap));
    Bitmap *smoothbmp = (Bitmap *)malloc(sizeof(Bitmap));
    Bitmap *binbmp = (Bitmap *)malloc(sizeof(Bitmap));
    Bitmap *temp = (Bitmap *)malloc(sizeof(Bitmap));
    int ret;
    char *path ="C:\\Users\\Ali\\Desktop\\1.bmp";
    ret = ReadBitmap(path, bmp);//读取图片
    char *savePath ="C:\\Users\\Ali\\Desktop\\zuizhong.bmp";
    RGB2Gray(bmp,graybmp);//转换成灰度图
    smooth(graybmp,smoothbmp);
    Gray2BW(smoothbmp,binbmp,155);//二值化
    pengzhang(binbmp, dstBmp);  
    pengzhang(dstBmp, temp);
    fushi(temp,dstBmp);
    qufan(dstBmp,temp);
    /*BYTE *bitmap = temp->imageData;
    int width = temp->width;
    int height = temp->height;
    int *labelmap;
    ConnectedComponentLabeling(bitmap, width, height,labelmap); 有待调整 此处是调用本博客的另一篇文章
    二值图像统计连通区域*/
    SaveBitmap(savePath,temp);//保存图片    
}

 

bmp.h

#ifndef BMP_H_INCLUDED
#define BMP_H_INCLUDED

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

/**
 * 位图文件结构及基本函数定义  打开和保存bmp文件
 */
typedef unsigned short WORD;
typedef unsigned long DWORD;
typedef long LONG;
typedef unsigned char BYTE;

/* 位图文件头结构 14字节 */
typedef struct tagBITMAPFILEHEADER {
    WORD bfType;
    DWORD bfSize;
    WORD bfReserved1;
    WORD bfReserved2;
    DWORD bfOffBits;
} BITMAPFILEHEADER;

/* 位图信息头结构 40字节 */
typedef struct tagBITMAPINFOHEADER {
    DWORD biSize; // 结构长度 40B
    LONG biWidth;
    LONG biHeight;
    WORD biPlanes; // 1
    WORD biBitCount; // 表示颜色要用到的位数
    DWORD biCompression; // 压缩格式
    DWORD biSizeImage; // 位图占用字节数=biWidth'（4的整倍数）*biHeight
    LONG biXPelsPerMeter; // 水平分辨率
    LONG biYPelsPerMeter; // 垂直分辨率
    DWORD biClrUsed; // 本图像用到的颜色数
    DWORD biClrImportant; // 本图像的重要颜色数
} BITMAPINFOHEADER;

/* 调色板 4字节 */
typedef struct tagRGBQUAD {
    BYTE rgbBlue;
    BYTE rgbGreen;
    BYTE rgbRed;
    BYTE rgbReserved;
} RGBQUAD;

/* 定义图像信息 */
typedef struct tagBITMAPINFO {
    BITMAPINFOHEADER bmiHeader;
    RGBQUAD bmiColors[1];
} BITMAPINFO;

/* 定义位图图像 */
typedef struct _Bitmap
{
    BITMAPFILEHEADER bmfh;
    BITMAPINFOHEADER bmih;
    int width;
    int height;
    int bitCount;    // 8 或者24
    int imageSize;    // 图像数据大小(imageSize=height*widthStep）字节
    BYTE* imageData;//排列的图像数据
    int widthStep;    //排列的图像行大小
}Bitmap;

/**
 * 位图创建函数  创建一个Bitmap结构，并为图像数据分配空间
 *
 * 使用方法：
 *     Bitmap *bmp=(Bitmap*)malloc(sizeof(Bitmap));
 *     ret=CreateBitmap(bmp,50,50,3);
 */
int CreateBitmap(Bitmap* bmp, int width, int height, int bitCount)
{
    bmp->width=width;
    bmp->height=height;
    bmp->bmih.biWidth=width;
    bmp->bmih.biHeight=height;

    bmp->widthStep=(int)((width*bitCount+31)/32)*4;        //计算排列的宽度
    bmp->imageSize=bmp->height*bmp->widthStep*sizeof(BYTE);//计算排列的图像大小

    if(bitCount==8)
    {
        bmp->bitCount=8;
        bmp->bmfh.bfType=0x4d42;    //注意是4d42 这个地方折磨我一下午啊
        bmp->bmfh.bfReserved1=0;
        bmp->bmfh.bfReserved2=0;
        bmp->bmih.biBitCount=8;
        bmp->bmih.biSize=40;
        bmp->bmih.biPlanes=1;
        bmp->bmfh.bfSize=54+256*4+height*bmp->widthStep;
        bmp->bmfh.bfOffBits=1078;
        bmp->bmih.biBitCount=8;
        bmp->bmih.biCompression=0;
        bmp->bmih.biSizeImage=bmp->imageSize;
        bmp->bmih.biClrUsed=0;
        bmp->bmih.biClrImportant=0;
        bmp->bmih.biXPelsPerMeter=0;
        bmp->bmih.biYPelsPerMeter=0;
    }
    else if (bitCount==24)
    {
        bmp->bitCount=24;
        bmp->bmfh.bfType=0x4d42;
        bmp->bmih.biBitCount=24;
        bmp->bmfh.bfReserved1=0;
        bmp->bmfh.bfReserved2=0;
        bmp->bmih.biSize=40;
        bmp->bmih.biPlanes=1;
        bmp->bmfh.bfSize=54+height*bmp->widthStep;
        bmp->bmfh.bfOffBits=54;
        bmp->bmih.biBitCount=24;
        bmp->bmih.biSizeImage=bmp->imageSize;
        bmp->bmih.biClrUsed=0;
        bmp->bmih.biCompression=0;
        bmp->bmih.biClrImportant=0;
        bmp->bmih.biXPelsPerMeter=0;
        bmp->bmih.biYPelsPerMeter=0;
    }
    else
    {
        printf("Error(CreateBitmap): only supported 8 or 24 bits bitmap.\n");
        return -1;
    }

    bmp->imageData=(BYTE*)malloc(bmp->imageSize);        //分配数据空间
    if(!(bmp->imageData))
    {
        printf("Error(CreateBitmap): can not allocate bitmap memory.\n");
        return -1;
    }
    return 0;
}

/**
 * 位图指针释放函数  释放位图数据空间
 *
 * 使用方法：
 *     ReleaseBitmap(bmp);
 */
void ReleaseBitmap(Bitmap* bmp)
{
    free(bmp->imageData);
    bmp->imageData=NULL;
    free(bmp);
    bmp=NULL;
}

/**
 * 路径检查函数：是否为BMP文件，是否可读
 * 正确返回0，错误返回-1
 *
 * 使用方法
 *         ret=CheckPath(path);
 */
int CheckPath(char *path)
{
    FILE *fd;
    int len = strlen(path) / sizeof(char);
    char ext[3];
    //check whether the path include the characters "bmp" at end
    strncpy(ext, &path[len - 3], 3);
    if (!(ext[0] == 'b' && ext[1] == 'm' && ext[2] == 'p')) {
        printf("Error(CheckPath): the extension of the file is not bmp.\n");
        return -1;
    }

    //check whether the file can be read or not
    fd = fopen(path, "r");
    if (!fd)
    {
        printf("Error(CheckPath): can not open the file.\n");
        return -1;
    }
    fclose(fd);

    return 0;
}

/**
 * 从文件中读取位图de函数
 * 正确返回0，错误返回-1
 *
 * 使用方法：
 *     bmp=(Bitmap*)malloc(sizeof(Bitmap));
 *     ret=ReadBitmap(path, bmp);
 */
int ReadBitmap(char* path, Bitmap* bmp)
{
    int ret;
    FILE *fd;

    //检查路径是否可读
    ret=CheckPath(path);
    if(ret==-1)
    {
        printf("Error(ReadBitmap): the path of the image is invalid.\n");
        return -1;
    }

    //打开文件
    fd=fopen(path,"rb");
    if(fd==0)
    {
        printf("Error(ReadBitmap): can not open the image.\n");
        return -1;
    }

    //读取文件信息头     14字节
    fread(&(bmp->bmfh.bfType),sizeof(WORD),1,fd);
    fread(&(bmp->bmfh.bfSize),sizeof(DWORD),1,fd);
    fread(&(bmp->bmfh.bfReserved1),sizeof(WORD),1,fd);
    fread(&(bmp->bmfh.bfReserved2),sizeof(WORD),1,fd);
    fread(&(bmp->bmfh.bfOffBits),sizeof(DWORD),1,fd);

    //读取位图信息头    40字节
    fread(&(bmp->bmih.biSize),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biWidth),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biHeight),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biPlanes),sizeof(WORD),1,fd);
    fread(&(bmp->bmih.biBitCount),sizeof(WORD),1,fd);
    fread(&(bmp->bmih.biCompression),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biSizeImage),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biXPelsPerMeter),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biYPelsPerMeter),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biClrUsed),sizeof(DWORD),1,fd);
    fread(&(bmp->bmih.biClrImportant),sizeof(DWORD),1,fd);

    //创建位图结构
    ret=CreateBitmap(bmp, bmp->bmih.biWidth, bmp->bmih.biHeight, bmp->bmih.biBitCount);
    if(ret==-1)
    {
        printf("Error(CreateBitmap): can not CreateBitmap.\n");
        return -1;
    }

    //读取图像数据
    //由于4字节对齐格式
    fseek(fd,bmp->bmfh.bfOffBits,SEEK_SET);    //定位到图像数据区
    ret=fread(bmp->imageData,bmp->imageSize,1,fd);
    if(ret==0)
    {
        if(feof(fd))    //if the file pointer point to the end of the file
        {
        }
        if(ferror(fd))  //if error happened while read the pixel data
        {
            printf("Error(ReadBitmap): can not read the pixel data.\n");
            fclose(fd);
            return -1;
        }
    }

    //关闭文件
    fclose(fd);
    return 0;
}

/**
 * 保存位图到文件中去
 * 正确返回0，错误返回-1
 *
 * 使用方法：
 *     bmp=(Bitmap*)malloc(sizeof(Bitmap));
 *     ret=SaveBitmap(path, bmp);
 */
int SaveBitmap(char* path, Bitmap* bmp)
{
    int ret;
    FILE *fd;

    //检查路径是否正确
    int len = strlen(path) / sizeof(char);
    char ext[3];
    //check whether the path include the characters "bmp" at end
    strncpy(ext, &path[len - 3], 3);
    if (!(ext[0] == 'b' && ext[1] == 'm' && ext[2] == 'p'))
    {
        printf("Error(SaveBitmap): the extension of the file is not bmp.\n");
        return -1;
    }

    //打开文件
    fd=fopen(path,"wb");
    if(fd==0)
    {
        printf("Error(SaveBitmap): can not open the image.\n");
        return -1;
    }

    //保存文件信息头     14字节
    fwrite(&(bmp->bmfh.bfType),sizeof(WORD),1,fd);
    fwrite(&(bmp->bmfh.bfSize),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmfh.bfReserved1),sizeof(WORD),1,fd);
    fwrite(&(bmp->bmfh.bfReserved2),sizeof(WORD),1,fd);
    fwrite(&(bmp->bmfh.bfOffBits),sizeof(DWORD),1,fd);

    //保存位图信息头    40字节
    fwrite(&(bmp->bmih.biSize),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biWidth),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biHeight),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biPlanes),sizeof(WORD),1,fd);
    fwrite(&(bmp->bmih.biBitCount),sizeof(WORD),1,fd);
    fwrite(&(bmp->bmih.biCompression),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biSizeImage),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biXPelsPerMeter),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biYPelsPerMeter),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biClrUsed),sizeof(DWORD),1,fd);
    fwrite(&(bmp->bmih.biClrImportant),sizeof(DWORD),1,fd);

    //如果为8位，则 保存调色板
    RGBQUAD pal[256];
    int i;
    if(bmp->bitCount==8)
    {
        for(i=0;i<256;i++)
        {
            pal[i].rgbBlue=i;
            pal[i].rgbGreen=i;
            pal[i].rgbRed=i;
            pal[i].rgbReserved=0;
        }
        if(fwrite(pal,sizeof(RGBQUAD)*256,1,fd)!=1)
        {
            printf("Error(SaveBitmap): can not write Color Palette.\n");
            return -1;
        }
    }


    //保存图像数据
    ret=fwrite(bmp->imageData,bmp->imageSize,1,fd);
    if(ret!=1)
    {
        printf("Error(SaveBitmap): can not save the pixel data.\n");
        return -1;
    }

    //关闭文件
    fclose(fd);

    return 0;
}

#endif // BMP_H_INCLUDED
​​​​​​​

basicprocess.h

#ifndef BASICPROCESS_H_
#define BASICPROCESS_H_
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
#include "bmp.h"
#include <math.h>
/**
 * <font color="#3f7f5f">位图图像基本处理函数  图像格式转换</font>
 */
int RGB2Gray(Bitmap* src, Bitmap* dst)
{
    int ret;
    int n=0,i,j;
    BYTE r,g,b,gray;

    //检查图像格式是否合法
    if(src->bitCount!=24)
    {
        printf("Error(RGB2Gray): the source image must be in RGB format.\n");
        return -1;
    }

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,8);
    if(ret==-1)
    {
        printf("Error(RGB2Gray): can't create target image.\n");
        return -1;
    }

    //计算灰度数据
    for(i=0;i<src->height;i++)
    {
        n=0;
        for(j=0;j<src->width*3;j++,n++)
        {
            b=*(src->imageData+src->widthStep*(src->height-1-i)+j);
            j++;
            g=*(src->imageData+src->widthStep*(src->height-1-i)+j);
            j++;
            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);
            gray=(r*19595 + g*38469 + b*7472) >> 16;
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=gray;
        }
    }

    return 0;
}

/**
 * Gray2RGB
 *
 * 使用方法：
 *        bmp=(Bitmap*)malloc(sizeof(Bitmap));
 *        ret=ReadBitmap(path, bmp);
 *        dstbmp=(Bitmap*)malloc(sizeof(Bitmap));
 *        ret=Gray2RGB(bmp,dstbmp);
 */
int Gray2RGB(Bitmap* src, Bitmap* dst)
{
    int ret;
    int n=0,i,j;
    BYTE r;

    //检查图像格式是否合法
    if(src->bitCount!=8)
    {
        printf("Error(Gray2RGB): the source image must be in gray scale.\n");
        return -1;
    }

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,24);
    if(ret==-1)
    {
        printf("Error(Gray2RGB): can't create target image.\n");
        return -1;
    }

    //计算灰度数据
    for(i=0;i<src->height;i++)
    {
        n=0;
        for(j=0;j<src->width;j++,n++)
        {
            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=r;
            n++;
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=r;
            n++;
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=r;
        }
    }

    return 0;
}

/**
 * Gray2BW 图像二值化
 *
 * 使用方法：
 *        bmp=(Bitmap*)malloc(sizeof(Bitmap));
 *        ret=ReadBitmap(path, bmp);
 *        dstbmp=(Bitmap*)malloc(sizeof(Bitmap));
 *        ret=Gray2BW(bmp,dstbmp);
 */
int Gray2BW(Bitmap* src, Bitmap* dst, int threshold)
{
    int ret;
    int n=0,i,j;
    BYTE r;

    //检查图像格式是否合法
    if(src->bitCount!=8)
    {
        printf("Error(Gray2BW): the source image must be in gray scale.\n");
        return -1;
    }

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,8);
    if(ret==-1)
    {
        printf("Error(Gray2BW): can't create target image.\n");
        return -1;
    }

    //计算灰度数据
    for(i=0;i<src->height;i++)
    {
        for(j=0;j<src->width;j++,n++)
        {
            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);
            if(r>=threshold)
            {
                n=255;
            }
            else
            {
                n=0;
            }
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=n;
        }
    }

    return 0;
}

/**
 *  rgb2hsv
 *  r,g,b values are from 0 to 1
 *  h = [0,360], s = [0,1], v = [0,1]
 *  if s == 0, then h = -1 (undefined)
 *  使用方法：
 *      rgb2hsv(0.2,0.3,0.3,&x,&y,&z);
 */
void rgb2hsv(float R, float G, float B, float *H, float *S, float* V)
{
    float min, max, delta,tmp;
    tmp = R<G?R:G;
    min = tmp<B?tmp:B;
    tmp = R>G?R:G;
    max = tmp>B?tmp:B;
    *V = max; // v

    delta = max - min;

    if( max != 0 )
      *S = delta / max; // s
    else
    {
       // r = g = b = 0 // s = 0, v is undefined
      *S = 0;
      *H = -1;
      return;
    }
    if( R == max )
        *H = ( G - B ) / delta; // between yellow & magenta
   else if( G == max )
        *H = 2 + ( B - R ) / delta; // between cyan & yellow
   else
       *H = 4 + ( R - G ) / delta; // between magenta & cyan

    (*H) *= 60; // degrees
    if( *H < 0 )
       (*H) += 360;
}


/**
 *  hsv2rgb
 *  r,g,b values are from 0 to 1
 *  h = [0,360], s = [0,1], v = [0,1]
 *  if s == 0, then h = -1 (undefined)
 *  使用方法：
 *       hsv2rgb(60,0.3,0.5,&x,&y,&z);
*/
void hsv2rgb(float H, float S, float V, float *R, float *G, float *B)
{
     int i;
    float f, p, q, t;

    if( S == 0 )
    {
        *R =*G = *B = V;
        return;
    }

    H /= 60; // sector 0 to 5
    i = floor( H );
    f = H - i; // factorial part of h
    p = V * ( 1 - S );
    q = V * ( 1 - S * f );
    t = V * ( 1 - S * ( 1 - f ) );

    switch( i )
    {
    case 0:
        *R = V;
        *G = t;
        *B = p;
       break;
    case 1:
       *R = q;
       *G = V;
       *B = p;
       break;
    case 2:
       *R = p;
       *G = V;
       *B = t;
       break;
    case 3:
       *R = p;
       *G = q;
       *B = V;
       break;
    case 4:
       *R = t;
       *G = p;
       *B = V;
       break;
    default: // case 5:
       *R = V;
       *G = p;
       *B = q;
       break;
    }
}



/**
 * 直方图均衡化
 * 返回 0正确 -1错误
 */
int HistEqualization(Bitmap* dstBmp, Bitmap* srcBmp)
{
    return 0;
}

/*
 * 中值滤波 
*/


int MedFilt(Bitmap* dstBmp, Bitmap* srcBmp)
{
    return 0;
}



//平滑去噪

int smooth(Bitmap* src, Bitmap* dst)
{
    int ret;
    int n=0,i,j;
    int sum;

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,8);
    if(ret==-1)
    {
        printf("Error(Gray2BW): can't create target image.\n");
        return -1;
    }

    for(i=1;i<src->height-1;i++)
    {
        for(j=1;j<src->width-1;j++)
        {   
            sum = 0;//clear sum
            sum+=*(src->imageData+src->widthStep*(src->height-1-i-1)+j-1);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i-1)+j);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i-1)+j+1);

            sum+=*(src->imageData+src->widthStep*(src->height-1-i)+j-1);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i)+j);// 该点
            sum+=*(src->imageData+src->widthStep*(src->height-1-i)+j+1);

            sum+=*(src->imageData+src->widthStep*(src->height-1-i+1)+j-1);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i+1)+j);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i+1)+j+1);

            *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=(sum/9);//赋值给目标


        }
    }

    return 0;
}




//膨胀

int pengzhang(Bitmap* src, Bitmap* dst)
{
    int ret;
    int n=0,i,j;
    int r;

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,8);
    if(ret==-1)
    {
        printf("Error(Gray2BW): can't create target image.\n");
        return -1;
    }

    for(i=1;i<src->height-1;i++)
    {
        for(j=1;j<src->width-1;j++)
        {   
            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);     
            if(r==0)
            {
            *(dst->imageData+dst->widthStep*(dst->height-1-i-1)+j-1)=0;
            *(dst->imageData+dst->widthStep*(dst->height-1-i-1)+j)=0;
            *(dst->imageData+dst->widthStep*(dst->height-1-i-1)+j+1)=0;

            *(dst->imageData+dst->widthStep*(dst->height-1-i)+j-1)=0;
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=0;
            *(dst->imageData+dst->widthStep*(dst->height-1-i)+j+1)=0;

            *(dst->imageData+dst->widthStep*(dst->height-1-i+1)+j-1)=0;
            *(dst->imageData+dst->widthStep*(dst->height-1-i+1)+j)=0;
            *(dst->imageData+dst->widthStep*(dst->height-1-i+1)+j+1)=0;
            }
            else *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=r;
        }
    }

    return 0;
}







int fushi(Bitmap* src, Bitmap* dst)
{
    int ret;
    int n=0,i,j;
    int r,sum;

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,8);
    if(ret==-1)
    {
        printf("Error(Gray2BW): can't create target image.\n");
        return -1;
    }

    for(i=1;i<src->height-1;i++)
    {
        for(j=1;j<src->width-1;j++)
        {   
            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);     

            if(r==0)
            {
            sum = 0;//clear sum
            sum+=*(src->imageData+src->widthStep*(src->height-1-i-1)+j-1);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i-1)+j);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i-1)+j+1);

            sum+=*(src->imageData+src->widthStep*(src->height-1-i)+j-1);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i)+j);// 该点
            sum+=*(src->imageData+src->widthStep*(src->height-1-i)+j+1);

            sum+=*(src->imageData+src->widthStep*(src->height-1-i+1)+j-1);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i+1)+j);
            sum+=*(src->imageData+src->widthStep*(src->height-1-i+1)+j+1);
            if(sum>=255){
                *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=255;}
            else {*(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=r;}
            }
            else *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=255;
        }
    }

    return 0;
}







int qufan(Bitmap* src, Bitmap* dst)
{
    int ret;
    int n=0,i,j;

    //为dst图像分配数据空间
    ret=CreateBitmap(dst,src->width,src->height,8);
    if(ret==-1)
    {
        printf("Error(Gray2BW): can't create target image.\n");
        return -1;
    }
    for(i=1;i<src->height-1;i++)
    {
        for(j=1;j<src->width-1;j++)
        {   

        *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=255-*(src->imageData+src->widthStep*(src->height-1-i)+j);
        }
    }

    return 0;
}

#endif /* BASICPROCESS_H_ */
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421
  • 422
  • 423
  • 424
  • 425
  • 426
  • 427
  • 428
  • 429
  • 430
  • 431
  • 432
  • 433
  • 434
  • 435
  • 436
  • 437
  • 438
  • 439
  • 440
  • 441
  • 442
  • 443
  • 444
  • 445
  • 446
  • 447
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421
  • 422
  • 423
  • 424
  • 425
  • 426
  • 427
  • 428
  • 429
  • 430
  • 431
  • 432
  • 433
  • 434
  • 435
  • 436
  • 437
  • 438
  • 439
  • 440
  • 441
  • 442
  • 443
  • 444
  • 445
  • 446
  • 447

效果图 中间过程图太多了，就不上了 这是最后的图。 
这里写图片描述 
废话不多说 直接show 代码 你们看吧。

北方的杨先生
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像处理-染色体计数
04-07
Matlab编写，用于染色体图像计数，包括反白、去噪、标记、统计等处理。
数字图像处理---数字、指纹、染色体特征提取
05-22
中国科学院大学刘定生老师的数字图像处理课的综合作业3---数字、指纹、染色体特征提取，内含代码及详细步骤
数字图像处理 染色体计数 Python实现
黄笳倞的博客
02-25 8794
目录 一、实验内容 二、实验步骤 三、代码 四、结果 一、实验内容 对于下面这幅图像，编程实现染色体计数，并附简要处理流程说明。 二、实验步骤 1.中值滤波 2.图像二值化 3.膨胀图像 4.腐蚀图像 5.计算光影背景 6.移除背景 7.检测染色体 三、代码 import cv2 import numpy as np # 计算光影背景 def calcu...
数字图像处理数细胞C++
05-14
根据细胞的颜色，数出多少个细胞，图形图像处理技术，图像分割
数字图像处理心得体会.docx
02-20
在生物医学工程中，数字图像处理技术可以应用于医用显微图像的处理分析，如红细胞、白细胞分类，染色体分析，癌细胞识别等。在通信工程中，数字图像处理技术可以应用于多媒体通信，如声音、文字、图像和数据结合的...
Digital-Image-Processing.rar_染色体图像
09-21
《数字图像处理——染色体图像分析》 在信息技术领域，数字图像处理是一门至关重要的技术，它广泛应用于医学诊断、生物科学、遥感、安全监控等诸多领域。本资料包"Digital-Image-Processing.rar_染色体图像"专注于...
数字图像处理心得体会 (2).pdf
02-20
"数字图像处理心得体会" 数字图像处理是指对图像信息进行加工，从而满足人类的心理、视觉或者应用的需求的一种行为。数字图像处理方法一般有数字法和光学法两种，其中数字法的优势很明显，已经被应用到了很多领域中...
基于数字图像处理的小目标计数（一）
u010030977的博客
04-17 9637
波点壁纸中圆点的计数 去年年末我学习了天津科技大学杨淑莹老师的《数字图像处理》课程，虽然课程有点老，但是内容还是比较经典的。课程最后有好几个数字图像处理的案例，都是基于Visual C++的，我使用Python实现其中的“细胞个数统计”，并进行了一定的探索。杨老师的视频在哔哩哔哩和MOOC都能获取。 解决思路： 转换色彩空间至HSV 根据H通道进行阈值分割 中值滤波去噪 腐蚀操作去除孤...
BJUT数字图像处理作业
晚晴小筑
01-10 449
一、 1) 将宽为2n的正方形图像，用FFT算法从空域变换到频域，并用频域图像的模来进行显示。 2) 使图像能量中心，对应到几何中心，并用频域图像的模来进行显示。 3)将频域图象，通过FFT逆变换到空域，并显示。 #include &lt;opencv2/imgproc.hpp&gt; #include &lt;opencv2/highgui.hpp&gt; #include &l...
C语言实用数字图像处理_源代码code
09-06
该部分为《C语言实用数字图像处理-井上诚喜,白玉林》_源代码code
二维傅里叶变换的C++实现
03-13
资源为二维傅里叶变换的C++实现，内含多个示例，比较详细。
基于Retinex的图像去雾算法（MATLAB实现）
热门推荐
白马负金羁
07-01 5万+
通常图像增强算法（例如直方图均衡算法以及更加强大的CLAHE）或多或少都有一定的去雾效果，只是这个效果有强有若罢了。本文将讨论另外一类十分重要的图像增强算法——Retinex算法。并在MATLAB中实验一下这类方法的去雾效果。Retinex（包括SSR、MSR和MSRCR）是一种常用的建立在科学实验和科学分析基础上的图像增强方法，它是以人类视觉系统为出发点发展而来的一套理论方法
生物细胞计数软件MATLAB代码实现
ling_robe的博客
07-22 1万+
    之前因为工作原因一直没将代码贴上来，这次我比较详细介绍下MATLAB的代码实现，有时间的话可能会出个视频教程。     首先说下界面设计，我这里只是说下都用了什么组件以及一些参数，具体的GUI怎么设计的我这里就不详细介绍，又需要介绍的可以给我留言我可以抽出点时间来简单介绍。     这里为了使参数可以灵活的调整，我在界面中将图像处理的每个关键的步骤都显现出来，根据图像来灵活的调整参数，...
如何实现图像访问计数器
网站开发初中级代码参考-转载
06-26 291
统计和显示页面的访问次数是一个常见的WEB应用，因为在网页每次被访问时，页面的访问次数都要发生改变，所以这个功能必须通过服务器端的程序来实现。页面访问计数器在服务器端的基本执行过程为：首先从数据库或其他存储系统中取出页面原来的访问次数，然后将原来的访问次数加1后再作为当前访问次数送给浏览器显示，同时将当前访问次数存储回数据库或其他存储系统中，以便下次访问该页面时使用。但是，一些WEB站点只能输出静...
图像处理_对象计数
weixin_39069578的博客
11-16 877
（1）二值分割 （2）形态学处理 （3）距离变换 （4）连通区域计算
傅立叶变换与傅立叶反变换的C语言实现
achejq的专栏
09-10 3366
#include    #include    #define pi (double) 3.14159265359   /*复数的定义*/   typedef struct   {       double re;       double im;   }COMPLEX;   /*复数的加运算*/   COMPLEX Add(COMPLEX c1, COMPLEX c2)
MATLAB图像处理实验——细胞图像的分割和计数
simon_family的博客
04-23 3万+
代码戳这里   1. 实验内容   本实验为使用MATLAB编写的细胞图像分割及计数系统，实现了对图像内细胞的计数，以及对每个细胞周长和面积的测量，并分别展示了分割后的每个细胞的图像。 实验步骤共分为图像预处理、图像预分割、空洞填充、黏连细胞分割、细胞个数统计、细胞特征统计及显示。 实验所用图像如下图所示： 2. 图像预处理   使用滤波对细胞图像进行保边去噪的处理，这步的主...
【图像处理】不智能的目标识别
最新发布
sqqwm的专栏
07-21 596
大家有没有想过在没有人工智能或者说没有机器学习的的时候，计算机是怎么做目标识别的？ 计算机视觉时至今日也是急需人才的领域，仍有很多未被攻克的方向，想要进入这个领域必须了解一些基础的图像处理知识，而目标识别是其中综合要求比较高的小课题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值