基于标准C语言的数字图像处理基本框架（转）

考虑到现有的数字图像处理都是基于Windows平台，都或多或少使用了Win32 API函数，不能移植到Linux或者嵌入式系统中。为了使程序可移植，采用标准C语言建立了数字图像处理的基本框架，如下图所示：

程序参考了网上一些博客的内容，并进行了改变，建立了符合自己习惯的数据结构。主要实现了bmp格式图像的打开、保存、创建、图像颜色空间转换等功能，暂时还没有添加具体的处理函数。我想，既然有了程序的框架，添加算法只是编写一个个函数的问题。

本程序具体实现的功能如下：

* 打开和保存bmp文件，这里使用自定义数据结构Bitmap，相关函数定义如下：
    bmp.h:
        int CreateBitmap(Bitmap* bmp, int width, int height, int bitCount);
        void ReleaseBitmap(Bitmap* bmp);
        int CheckPath(char *path);
        int ReadBitmap(char* path, Bitmap* bmp);
        int SaveBitmap(char* path, Bitmap* bmp);

* 图像格式转换
    basicprocess.h:
        int RGB2Gray(Bitmap* src, Bitmap* dst);
        int Gray2RGB(Bitmap* src, Bitmap* dst);
        int Gray2BW(Bitmap* src, Bitmap* dst, int threshold);
        void hsv2rgb(float H, float S, float V, float *R, float *G, float *B);
        void rgb2hsv(float R, float G, float B, float *H, float *S, float* V);

程序源码如下，欢迎大家批评指正。

1/*
  2****************************************Copyright (c)**************************************************
  3**                                           Feisky
  4**                              http://www.cnblogs.com/feisky/
  5**
  6**------------------------------------- File Info ------------------------------------------------------
  7** File name:           bmp.h
  8** Last modified Date:  2009-9-25
  9** Last Version:        1.0
10** Descriptions:        位图文件结构及基本函数定义  打开和保存bmp文件
11**
12** Created by:          Feisky
13** Created date:        2009-07-25
14** Version:             1.0
15** Descriptions:        Preliminary version.
16**
17**------------------------------------------------------------------------------------------------------
18*/
19#ifndef BMP_H_INCLUDED
20#define BMP_H_INCLUDED
21
22#include <ctype.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <malloc.h>
26#include <string.h>
27
28/**
29 * 位图文件结构及基本函数定义  打开和保存bmp文件
30 */
31typedef unsigned short WORD;
32typedef unsigned long DWORD;
33typedef long LONG;
34typedef unsigned char BYTE;
35
36/* 位图文件头结构 14字节 */
37typedef struct tagBITMAPFILEHEADER {
38    WORD bfType;
39    DWORD bfSize;
40    WORD bfReserved1;
41    WORD bfReserved2;
42    DWORD bfOffBits;
43} BITMAPFILEHEADER;
44
45/* 位图信息头结构 40字节 */
46typedef struct tagBITMAPINFOHEADER {
47    DWORD biSize; // 结构长度 40B
48    LONG biWidth;
49    LONG biHeight;
50    WORD biPlanes; // 1
51    WORD biBitCount; // 表示颜色要用到的位数
52    DWORD biCompression; // 压缩格式
53    DWORD biSizeImage; // 位图占用字节数=biWidth'（4的整倍数）*biHeight
54    LONG biXPelsPerMeter; // 水平分辨率
55    LONG biYPelsPerMeter; // 垂直分辨率
56    DWORD biClrUsed; // 本图像用到的颜色数
57    DWORD biClrImportant; // 本图像的重要颜色数
58} BITMAPINFOHEADER;
59
60/* 调色板 4字节 */
61typedef struct tagRGBQUAD {
62    BYTE rgbBlue;
63    BYTE rgbGreen;
64    BYTE rgbRed;
65    BYTE rgbReserved;
66} RGBQUAD;
67
68/* 定义图像信息 */
69typedef struct tagBITMAPINFO {
70    BITMAPINFOHEADER bmiHeader;
71    RGBQUAD bmiColors[1];
72} BITMAPINFO;
73
74/* 定义位图图像 */
75typedef struct _Bitmap
76{
77    BITMAPFILEHEADER bmfh;
78    BITMAPINFOHEADER bmih;
79    int width;
80    int height;
81    int bitCount;    // 8 或者24
82    int imageSize;    // 图像数据大小(imageSize=height*widthStep）字节
83    BYTE* imageData;//排列的图像数据
84    int widthStep;    //排列的图像行大小
85}Bitmap;
86
87/**
88 * 位图创建函数  创建一个Bitmap结构，并为图像数据分配空间
89 *
90 * 使用方法：
91 *     Bitmap *bmp=(Bitmap*)malloc(sizeof(Bitmap));
92 *     ret=CreateBitmap(bmp,50,50,3);
93 */
94int CreateBitmap(Bitmap* bmp, int width, int height, int bitCount)
95{
96    bmp->width=width;
97    bmp->height=height;
98    bmp->bmih.biWidth=width;
99    bmp->bmih.biHeight=height;
100
101    bmp->widthStep=(int)((width*bitCount+31)/32)*4;        //计算排列的宽度
102    bmp->imageSize=bmp->height*bmp->widthStep*sizeof(BYTE);//计算排列的图像大小
103
104    if(bitCount==8)
105    {
106        bmp->bitCount=8;
107        bmp->bmfh.bfType=0x4d42;    //注意是4d42 这个地方折磨我一下午啊
108        bmp->bmfh.bfReserved1=0;
109        bmp->bmfh.bfReserved2=0;
110        bmp->bmih.biBitCount=8;
111        bmp->bmih.biSize=40;
112        bmp->bmih.biPlanes=1;
113        bmp->bmfh.bfSize=54+256*4+height*bmp->widthStep;
114        bmp->bmfh.bfOffBits=1078;
115        bmp->bmih.biBitCount=8;
116        bmp->bmih.biCompression=0;
117        bmp->bmih.biSizeImage=bmp->imageSize;
118        bmp->bmih.biClrUsed=0;
119        bmp->bmih.biClrImportant=0;
120        bmp->bmih.biXPelsPerMeter=0;
121        bmp->bmih.biYPelsPerMeter=0;
122    }
123    else if (bitCount==24)
124    {
125        bmp->bitCount=24;
126        bmp->bmfh.bfType=0x4d42;
127        bmp->bmih.biBitCount=24;
128        bmp->bmfh.bfReserved1=0;
129        bmp->bmfh.bfReserved2=0;
130        bmp->bmih.biSize=40;
131        bmp->bmih.biPlanes=1;
132        bmp->bmfh.bfSize=54+height*bmp->widthStep;
133        bmp->bmfh.bfOffBits=54;
134        bmp->bmih.biBitCount=24;
135        bmp->bmih.biSizeImage=bmp->imageSize;
136        bmp->bmih.biClrUsed=0;
137        bmp->bmih.biCompression=0;
138        bmp->bmih.biClrImportant=0;
139        bmp->bmih.biXPelsPerMeter=0;
140        bmp->bmih.biYPelsPerMeter=0;
141    }
142    else
143    {
144        printf("Error(CreateBitmap): only supported 8 or 24 bits bitmap.\n");
145        return -1;
146    }
147
148    bmp->imageData=(BYTE*)malloc(bmp->imageSize);        //分配数据空间
149    if(!(bmp->imageData))
150    {
151        printf("Error(CreateBitmap): can not allocate bitmap memory.\n");
152        return -1;
153    }
154    return 0;
155}
156
157/**
158 * 位图指针释放函数  释放位图数据空间
159 *
160 * 使用方法：
161 *     ReleaseBitmap(bmp);
162 */
163void ReleaseBitmap(Bitmap* bmp)
164{
165    free(bmp->imageData);
166    bmp->imageData=NULL;
167    free(bmp);
168    bmp=NULL;
169}
170
171/**
172 * 路径检查函数：是否为BMP文件，是否可读
173 * 正确返回0，错误返回-1
174 *
175 * 使用方法
176 *         ret=CheckPath(path);
177 */
178int CheckPath(char *path)
179{
180    FILE *fd;
181    int len = strlen(path) / sizeof(char);
182    char ext[3];
183    //check whether the path include the characters "bmp" at end
184    strncpy(ext, &path[len - 3], 3);
185    if (!(ext[0] == 'b' && ext[1] == 'm' && ext[2] == 'p')) {
186        printf("Error(CheckPath): the extension of the file is not bmp.\n");
187        return -1;
188    }
189
190    //check whether the file can be read or not
191    fd = fopen(path, "r");
192    if (!fd)
193    {
194        printf("Error(CheckPath): can not open the file.\n");
195        return -1;
196    }
197    fclose(fd);
198
199    return 0;
200}
201
202/**
203 * 从文件中读取位图函数
204 * 正确返回0，错误返回-1
205 *
206 * 使用方法：
207 *     bmp=(Bitmap*)malloc(sizeof(Bitmap));
208 *     ret=ReadBitmap(path, bmp);
209 */
210int ReadBitmap(char* path, Bitmap* bmp)
211{
212    int ret;
213    FILE *fd;
214
215    //检查路径是否可读
216    ret=CheckPath(path);
217    if(ret==-1)
218    {
219        printf("Error(ReadBitmap): the path of the image is invalid.\n");
220        return -1;
221    }
222
223    //打开文件
224    fd=fopen(path,"rb");
225    if(fd==0)
226    {
227        printf("Error(ReadBitmap): can not open the image.\n");
228        return -1;
229    }
230
231    //读取文件信息头     14字节
232    fread(&(bmp->bmfh.bfType),sizeof(WORD),1,fd);
233    fread(&(bmp->bmfh.bfSize),sizeof(DWORD),1,fd);
234    fread(&(bmp->bmfh.bfReserved1),sizeof(WORD),1,fd);
235    fread(&(bmp->bmfh.bfReserved2),sizeof(WORD),1,fd);
236    fread(&(bmp->bmfh.bfOffBits),sizeof(DWORD),1,fd);
237
238    //读取位图信息头    40字节
239    fread(&(bmp->bmih.biSize),sizeof(DWORD),1,fd);
240    fread(&(bmp->bmih.biWidth),sizeof(DWORD),1,fd);
241    fread(&(bmp->bmih.biHeight),sizeof(DWORD),1,fd);
242    fread(&(bmp->bmih.biPlanes),sizeof(WORD),1,fd);
243    fread(&(bmp->bmih.biBitCount),sizeof(WORD),1,fd);
244    fread(&(bmp->bmih.biCompression),sizeof(DWORD),1,fd);
245    fread(&(bmp->bmih.biSizeImage),sizeof(DWORD),1,fd);
246    fread(&(bmp->bmih.biXPelsPerMeter),sizeof(DWORD),1,fd);
247    fread(&(bmp->bmih.biYPelsPerMeter),sizeof(DWORD),1,fd);
248    fread(&(bmp->bmih.biClrUsed),sizeof(DWORD),1,fd);
249    fread(&(bmp->bmih.biClrImportant),sizeof(DWORD),1,fd);
250
251    //创建位图结构
252    ret=CreateBitmap(bmp, bmp->bmih.biWidth, bmp->bmih.biHeight, bmp->bmih.biBitCount);
253    if(ret==-1)
254    {
255        printf("Error(CreateBitmap): can not CreateBitmap.\n");
256        return -1;
257    }
258
259    //读取图像数据
260    //由于4字节对齐格式
261    fseek(fd,bmp->bmfh.bfOffBits,SEEK_SET);    //定位到图像数据区
262    ret=fread(bmp->imageData,bmp->imageSize,1,fd);
263    if(ret==0)
264    {
265        if(feof(fd))    //if the file pointer point to the end of the file
266        {
267        }
268        if(ferror(fd))  //if error happened while read the pixel data
269        {
270            printf("Error(ReadBitmap): can not read the pixel data.\n");
271            fclose(fd);
272            return -1;
273        }
274    }
275
276    //关闭文件
277    fclose(fd);
278    return 0;
279}
280
281/**
282 * 保存位图到文件中去
283 * 正确返回0，错误返回-1
284 *
285 * 使用方法：
286 *     bmp=(Bitmap*)malloc(sizeof(Bitmap));
287 *     ret=SaveBitmap(path, bmp);
288 */
289int SaveBitmap(char* path, Bitmap* bmp)
290{
291    int ret;
292    FILE *fd;
293
294    //检查路径是否正确
295    int len = strlen(path) / sizeof(char);
296    char ext[3];
297    //check whether the path include the characters "bmp" at end
298    strncpy(ext, &path[len - 3], 3);
299    if (!(ext[0] == 'b' && ext[1] == 'm' && ext[2] == 'p'))
300    {
301        printf("Error(SaveBitmap): the extension of the file is not bmp.\n");
302        return -1;
303    }
304
305    //打开文件
306    fd=fopen(path,"wb");
307    if(fd==0)
308    {
309        printf("Error(SaveBitmap): can not open the image.\n");
310        return -1;
311    }
312
313    //保存文件信息头     14字节
314    fwrite(&(bmp->bmfh.bfType),sizeof(WORD),1,fd);
315    fwrite(&(bmp->bmfh.bfSize),sizeof(DWORD),1,fd);
316    fwrite(&(bmp->bmfh.bfReserved1),sizeof(WORD),1,fd);
317    fwrite(&(bmp->bmfh.bfReserved2),sizeof(WORD),1,fd);
318    fwrite(&(bmp->bmfh.bfOffBits),sizeof(DWORD),1,fd);
319
320    //保存位图信息头    40字节
321    fwrite(&(bmp->bmih.biSize),sizeof(DWORD),1,fd);
322    fwrite(&(bmp->bmih.biWidth),sizeof(DWORD),1,fd);
323    fwrite(&(bmp->bmih.biHeight),sizeof(DWORD),1,fd);
324    fwrite(&(bmp->bmih.biPlanes),sizeof(WORD),1,fd);
325    fwrite(&(bmp->bmih.biBitCount),sizeof(WORD),1,fd);
326    fwrite(&(bmp->bmih.biCompression),sizeof(DWORD),1,fd);
327    fwrite(&(bmp->bmih.biSizeImage),sizeof(DWORD),1,fd);
328    fwrite(&(bmp->bmih.biXPelsPerMeter),sizeof(DWORD),1,fd);
329    fwrite(&(bmp->bmih.biYPelsPerMeter),sizeof(DWORD),1,fd);
330    fwrite(&(bmp->bmih.biClrUsed),sizeof(DWORD),1,fd);
331    fwrite(&(bmp->bmih.biClrImportant),sizeof(DWORD),1,fd);
332
333    //如果为8位，则保存调色板
334    RGBQUAD pal[256];
335    int i;
336    if(bmp->bitCount==8)
337    {
338        for(i=0;i<256;i++)
339        {
340            pal[i].rgbBlue=i;
341            pal[i].rgbGreen=i;
342            pal[i].rgbRed=i;
343            pal[i].rgbReserved=0;
344        }
345        if(fwrite(pal,sizeof(RGBQUAD)*256,1,fd)!=1)
346        {
347            printf("Error(SaveBitmap): can not write Color Palette.\n");
348            return -1;
349        }
350    }
351
352
353    //保存图像数据
354    ret=fwrite(bmp->imageData,bmp->imageSize,1,fd);
355    if(ret!=1)
356    {
357        printf("Error(SaveBitmap): can not save the pixel data.\n");
358        return -1;
359    }
360
361    //关闭文件
362    fclose(fd);
363
364    return 0;
365}
366
367#endif // BMP_H_INCLUDED
368
369
370
371
372
373/*
374****************************************Copyright (c)**************************************************
375**                                           Feisky
376**                            http://www.cnblogs.com/feisky/
377**
378**------------------------------------- File Info ------------------------------------------------------
379** File name:           basicprocess.h
380** Last modified Date:  2009-9-28
381** Last Version:        1.0
382** Descriptions:        位图图像基本处理函数  图像格式转换
383**
384** Created by:          Feisky
385** Created date:        2009-9-28
386** Version:             1.0
387** Descriptions:        Preliminary version.
388**
389**------------------------------------------------------------------------------------------------------
390*/
391
392#ifndef BASICPROCESS_H_
393#define BASICPROCESS_H_
394
395#include "bmp.h"
396#include <math.h>
397/**
398 * <font color="#3f7f5f">位图图像基本处理函数  图像格式转换</font>
399 */
400int RGB2Gray(Bitmap* src, Bitmap* dst)
401{
402    int ret;
403    int n=0,i,j;
404    BYTE r,g,b,gray;
405
406    //检查图像格式是否合法
407    if(src->bitCount!=24)
408    {
409        printf("Error(RGB2Gray): the source image must be in RGB format.\n");
410        return -1;
411    }
412
413    //为dst图像分配数据空间
414    ret=CreateBitmap(dst,src->width,src->height,8);
415    if(ret==-1)
416    {
417        printf("Error(RGB2Gray): can't create target image.\n");
418        return -1;
419    }
420
421    //计算灰度数据
422    for(i=0;i<src->height;i++)
423    {
424        n=0;
425        for(j=0;j<src->width*3;j++,n++)
426        {
427            b=*(src->imageData+src->widthStep*(src->height-1-i)+j);
428            j++;
429            g=*(src->imageData+src->widthStep*(src->height-1-i)+j);
430            j++;
431            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);
432            gray=(r*19595 + g*38469 + b*7472) >> 16;
433            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=gray;
434        }
435    }
436
437    return 0;
438}
439
440/**
441 * Gray2RGB
442 *
443 * 使用方法：
444 *        bmp=(Bitmap*)malloc(sizeof(Bitmap));
445 *        ret=ReadBitmap(path, bmp);
446 *        dstbmp=(Bitmap*)malloc(sizeof(Bitmap));
447 *        ret=Gray2RGB(bmp,dstbmp);
448 */
449int Gray2RGB(Bitmap* src, Bitmap* dst)
450{
451    int ret;
452    int n=0,i,j;
453    BYTE r;
454
455    //检查图像格式是否合法
456    if(src->bitCount!=8)
457    {
458        printf("Error(Gray2RGB): the source image must be in gray scale.\n");
459        return -1;
460    }
461
462    //为dst图像分配数据空间
463    ret=CreateBitmap(dst,src->width,src->height,24);
464    if(ret==-1)
465    {
466        printf("Error(Gray2RGB): can't create target image.\n");
467        return -1;
468    }
469
470    //计算灰度数据
471    for(i=0;i<src->height;i++)
472    {
473        n=0;
474        for(j=0;j<src->width;j++,n++)
475        {
476            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);
477            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=r;
478            n++;
479            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=r;
480            n++;
481            *(dst->imageData+dst->widthStep*(dst->height-1-i)+n)=r;
482        }
483    }
484
485    return 0;
486}
487
488/**
489 * Gray2BW 图像二值化
490 *
491 * 使用方法：
492 *        bmp=(Bitmap*)malloc(sizeof(Bitmap));
493 *        ret=ReadBitmap(path, bmp);
494 *        dstbmp=(Bitmap*)malloc(sizeof(Bitmap));
495 *        ret=Gray2BW(bmp,dstbmp);
496 */
497int Gray2BW(Bitmap* src, Bitmap* dst, int threshold)
498{
499    int ret;
500    int n=0,i,j;
501    BYTE r;
502
503    //检查图像格式是否合法
504    if(src->bitCount!=8)
505    {
506        printf("Error(Gray2BW): the source image must be in gray scale.\n");
507        return -1;
508    }
509
510    //为dst图像分配数据空间
511    ret=CreateBitmap(dst,src->width,src->height,8);
512    if(ret==-1)
513    {
514        printf("Error(Gray2BW): can't create target image.\n");
515        return -1;
516    }
517
518    //计算灰度数据
519    for(i=0;i<src->height;i++)
520    {
521        for(j=0;j<src->width;j++,n++)
522        {
523            r=*(src->imageData+src->widthStep*(src->height-1-i)+j);
524            if(r>=threshold)
525            {
526                n=255;
527            }
528            else
529            {
530                n=0;
531            }
532            *(dst->imageData+dst->widthStep*(dst->height-1-i)+j)=n;
533        }
534    }
535
536    return 0;
537}
538
539/**
540 *  rgb2hsv
541 *  r,g,b values are from 0 to 1
542 *  h = [0,360], s = [0,1], v = [0,1]
543 *  if s == 0, then h = -1 (undefined)
544 *  使用方法：
545 *      rgb2hsv(0.2,0.3,0.3,&x,&y,&z);
546 */
547void rgb2hsv(float R, float G, float B, float *H, float *S, float* V)
548{
549    float min, max, delta,tmp;
550    tmp = R<G?R:G;
551    min = tmp<B?tmp:B;
552    tmp = R>G?R:G;
553    max = tmp>B?tmp:B;
554    *V = max; // v
555
556    delta = max - min;
557
558    if( max != 0 )
559      *S = delta / max; // s
560    else
561    {
562       // r = g = b = 0 // s = 0, v is undefined
563      *S = 0;
564      *H = -1;
565      return;
566    }
567    if( R == max )
568        *H = ( G - B ) / delta; // between yellow & magenta
569   else if( G == max )
570        *H = 2 + ( B - R ) / delta; // between cyan & yellow
571   else
572       *H = 4 + ( R - G ) / delta; // between magenta & cyan
573
574    (*H) *= 60; // degrees
575    if( *H < 0 )
576       (*H) += 360;
577}
578
579
580/**
581 *  hsv2rgb
582 *  r,g,b values are from 0 to 1
583 *  h = [0,360], s = [0,1], v = [0,1]
584 *  if s == 0, then h = -1 (undefined)
585 *  使用方法：
586 *       hsv2rgb(60,0.3,0.5,&x,&y,&z);
587 */
588void hsv2rgb(float H, float S, float V, float *R, float *G, float *B)
589{
590     int i;
591    float f, p, q, t;
592
593    if( S == 0 )
594    {
595        *R =*G = *B = V;
596        return;
597    }
598
599    H /= 60; // sector 0 to 5
600    i = floor( H );
601    f = H - i; // factorial part of h
602    p = V * ( 1 - S );
603    q = V * ( 1 - S * f );
604    t = V * ( 1 - S * ( 1 - f ) );
605
606    switch( i )
607    {
608    case 0:
609        *R = V;
610        *G = t;
611        *B = p;
612       break;
613    case 1:
614       *R = q;
615       *G = V;
616       *B = p;
617       break;
618    case 2:
619       *R = p;
620       *G = V;
621       *B = t;
622       break;
623    case 3:
624       *R = p;
625       *G = q;
626       *B = V;
627       break;
628    case 4:
629       *R = t;
630       *G = p;
631       *B = V;
632       break;
633    default: // case 5:
634       *R = V;
635       *G = p;
636       *B = q;
637       break;
638    }
639}
640
641/**
642 * 直方图均衡化
643 * 返回 0正确 -1错误
644 */
645int HistEqualization(Bitmap* dstBmp, Bitmap* srcBmp)
646{
647    return 0;
648}
649
650/*
651 * 中值滤波
652*/
653
654int MedFilt(Bitmap* dstBmp, Bitmap* srcBmp)
655{
656    return 0;
657}
658
659#endif /* BASICPROCESS_H_ */

基于标准C语言的数字图像处理基本框架（转）相关推荐

基于MATLAB的GUI界面数字图像处理系统
目录实验一 MATLAB数字图像处理初步实验二图像的代数运算实验三图像增强-空间滤波实验四图像分割实验一 MATLAB数字图像处理初步一.实验目的与要求 1．熟悉及掌握在MATLAB ...
图像分割的java程序_基于java的图像分割（数字图像处理）
[实例简介] 基于java的图像分割(数字图像处理),程序中包含全局阈值分割,Roberts边缘检测分割,灰度图像,直方图. [实例截图] [核心代码] ImageProcess └── Image ...
图像直方图均衡化c语言程序,数字图像处理——直方图均衡化
1.相关了解直方图均衡化又称为直方图平坦化.直方图均衡化的基本思想是将原始图像的不均衡的直方图变换为均匀分布的形式.即将输入图像转化为在每一灰度级上都有相同的像素点数(即输出的直方图是平坦的,其分布 ...
linux下图像分析程序,三 - Linux+C语言：数字图像处理源程序_Linux编程_Linux公社-Linux系统门户网站...
main.c的源程序: #include #include #include //包含BMP文件的结构的声明 #include "BMP.h" //包含BMP文件的读写操作的函数 ...
基于MATLAB的数字图像处理的设计与实现转
基于MAT [摘要]数字图像处理是一门新兴技术,随着计算机硬件的发展,数字图像的实时处理已经成为可能,由于数字图像处理的各种算法的出现,使得其处理速度越来越快,能更好的为人们服务.数字图像处理是一种通 ...
（附源码）python数字图像处理课程平台毕业设计 242339
Python数字图像处理课程平台的开发摘要数字图像处理是一门新兴技术,随着计算机硬件的发展,数字图像的实时处理已经成为可能,由于数字图像处理的各种算法的出现,使得其处理速度越来越快,能更好的为人 ...
数字图像处理的研究方法
数字图像处理是近年来电子.通讯和计算机等领域的热门研究领域,其在科研.经济.军事.娱乐等等国计民生的各个领域都具有非常广阔的应用前景.数字图像处理处是一门交叉学科,涉及数学.计算机.电子.通讯.物理等 ...
（附源码）Python数字图像处理课程平台毕业设计242339
Python数字图像处理课程平台的开发摘要数字图像处理是一门新兴技术,随着计算机硬件的发展,数字图像的实时处理已经成为可能,由于数字图像处理的各种算法的出现,使得其处理速度越来越快,能更好的为人 ...
Matlab 数字图像处理1---图像的收缩和放大
内插是在放大.收缩.旋转和几何校正等任务中广泛应用的基本工具. 最近邻内插法(nearest): 原图像中寻找最接近的像素,并把该像素的灰度赋给新像素. 双线性内插法(bilinear):用4个最近邻 ...

基于标准C语言的数字图像处理基本框架（转）

基于标准C语言的数字图像处理基本框架（转）相关推荐

最新文章

热门文章