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 */

 31 typedef unsigned  short  WORD;

 32 typedef unsigned  long  DWORD;

 33 typedef  long  LONG;

 34 typedef unsigned  char  BYTE;

 35

 36 /* 位图文件头结构 14字节 */

 37 typedef  struct  tagBITMAPFILEHEADER  {

 38    WORD bfType;

 39    DWORD bfSize;

 40    WORD bfReserved1;

 41    WORD bfReserved2;

 42    DWORD bfOffBits;

 43}  BITMAPFILEHEADER;

 44

 45 /* 位图信息头结构 40字节 */

 46 typedef  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字节 */

 61 typedef  struct  tagRGBQUAD  {

 62    BYTE rgbBlue;

 63    BYTE rgbGreen;

 64    BYTE rgbRed;

 65    BYTE rgbReserved;

 66}  RGBQUAD;

 67

 68 /* 定义图像信息 */

 69 typedef  struct  tagBITMAPINFO  {

 70    BITMAPINFOHEADER bmiHeader;

 71    RGBQUAD bmiColors[1];

 72}  BITMAPINFO;

 73

 74 /* 定义位图图像 */

 75 typedef  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 */

 94 int  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 */

163 void  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 */

178 int  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 */

210 int  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 */

289 int  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 */

400 int  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 */

449 int  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 */

497 int  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 */

547 void  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 */

588 void  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 */

645 int  HistEqualization(Bitmap *  dstBmp, Bitmap *  srcBmp)

646 {

647    return 0;

648}

649

650 /*

651 * 中值滤波

652*/

653

654 int  MedFilt(Bitmap *  dstBmp, Bitmap *  srcBmp)

655 {

656    return 0;

657}

658

659 #endif  /* BASICPROCESS_H_ */