Category

Development Platform
Home > SourceCode/Document > Graph program > OpenCV > View Code
PICTURE.CPP
Package: openglsystem.rar　[view]
Upload User: nthssl
Upload Date: 2022-04-05
Package Size: 25357k
Code Size: 9k
Category:

OpenCV

Development Platform:

Visual C++

PICTURE.CPP：Code Content
  1. #include "stdafx.h"
  2. #include <memory.h>
  3. #include <stdio.h>
  4. #include <math.h>
  5. #include <stdlib.h>
  6. #include "jpeg.h"
  8. int sizes[]={ 1,2,4,8,16,32,64,128,256 };
  9. int nsizes=8;
  11. int byteRGB::Intensity(void)
  12. {
  13.     return (int)(r*299/1000 + g*587/1000 + b*114/1000);
  14. }
  16. void byteRGB::ToYIQ(void)
  17. {
  18. unsigned char y,i,q;
  20. y=(299*r+587*g+114*b)/1000;
  21. i=(596*r-275*g-321*b)/1192+127;
  22. q=(212*r-523*g+311*b)/1046+127;
  24. y=((int)y-127)*2/3+127;
  25. i=((int)i-127)*2/3+127;
  26. q=((int)q-127)*2/3+127;
  28. r=y;
  29. g=i;
  30. b=q;
  31. }
  33. void byteRGB::FromYIQ(void)
  34. {
  35. unsigned char y,i,q;
  36. int u,I,Q;
  37. I=((int)g-127)*166/127;
  38. Q=((int)b-127)*148/127;
  40. u=(int)r+(956*I+621*Q)/1000;
  41. u=(u-127)*3/2+127;
  42. y=u<0?0:u>255?255:u;
  43. u=(int)r-(272*I+647*Q)/1000;
  44. u=(u-127)*3/2+127;
  45. i=u<0?0:u>255?255:u;
  46. u=(int)r+(1703*Q-1106*I)/1000;
  47. u=(u-127)*3/2+127;
  48. q=u<0?0:u>255?255:u;
  50. r=y;
  51. g=i;
  52. b=q;
  53. }
  55. void picture::ErasePicture(char c)
  56. {
  57.      int a;
  58.      for( a=0;a<sy;a++ )
  59.           memset(buf[a],c,sx*bytespixel);
  60. }
  62. int picture::CreatePicture24(int xd,int yd)
  63. {
  64.     int a;
  65.     sx=xd; sy=yd; bytespixel=3;
  67.     if ((buf=new unsigned char *[sy])!=0)
  68.        {
  69. buf[0]=new unsigned char[sx*sy*bytespixel];
  70. if (!buf[0])
  71. {
  72. delete buf;
  73. buf=0;
  74. return 0;
  75. }
  76.         for( a=1;a<sy;a++ )
  77. buf[a]=&buf[0][a*sx*bytespixel];
  78.         return 1;
  79.        }
  80.     return 0;
  81. }
  83. int picture::CreatePicture8(int xd,int yd,int palsize)
  84. {
  85.     int a;
  86.     sx=xd; sy=yd; bytespixel=1;
  88.     if ((buf=new unsigned char *[sy])!=0)
  89.        {
  90. buf[0]=new unsigned char[sx*sy];
  91. if (!buf[0])
  92. {
  93. delete buf;
  94. buf=0;
  95. return 0;
  96. }
  97.         for( a=1;a<sy;a++ )
  98. buf[a]=&buf[0][a*sx];
  99. if (palsize)
  100. {
  101. pal=new byteRGB[palsize];
  102. npal=palsize;
  103. }
  104.         return 1;
  105.        }
  107.     return 0;
  108. }
  110. void picture::FreePicture(void)
  111. {
  112. if (buf)
  113. {
  114. delete buf[0];
  115. delete buf;
  116. }
  117. if (pal) 
  118. delete pal;
  119. if (icon)
  120. delete icon;
  122. buf=0;
  123. pal=0;
  124. npal=0;
  125. icon=0;
  126. }
  128. int picture::LoadTGA(char *name)
  129. {
  130.     FILE *fp;
  131.     int a;
  132. unsigned char flag;
  133. unsigned char TGA_INI[18];
  134.     sx=sy=0;
  136. FreePicture();
  138.     if ((fp=fopen(name,"rb"))!=0)
  139.        {
  140.         fread((char *)&TGA_INI[0],18,1,fp);
  141.   if (TGA_INI[16]!=24 || TGA_INI[2]!=2)
  142.   {
  143. fclose(fp);
  144. return 0;
  145.   }
  146. sx=TGA_INI[12]+256*TGA_INI[13];
  147.         sy=TGA_INI[14]+256*TGA_INI[15];
  148. CreatePicture24(sx,sy);
  149.         for( a=sy-1;a>=0;a-- )
  150.             {
  151.               fread((char *)buf[a],sx,3,fp);
  153.   int z=0,p=0;
  154.               for( ;z<sx;z++,p+=3 )
  155.                    {
  156.                     flag=buf[a][p+2];
  157.                     buf[a][p+2]=buf[a][p];
  158.                     buf[a][p]=flag;
  159.                    }
  160. }
  161.         fclose(fp);
  162. build_icon();
  163.         return 1;
  164.        }
  165.     return 0;
  166. }
  168. int picture::SaveTGA(char *name)
  169. {
  170.     FILE *fp;
  171.     int a,b;
  172.     unsigned char TGA_INI[18];
  173.     byteRGB *picline;
  175.     picline=new byteRGB[sx];
  176.     if (!picline)
  177.        return 0;
  179.     if ((fp=fopen(name,"wb"))!=0)
  180.        {
  181.         memset(&TGA_INI[0],0,18);
  182.         TGA_INI[12]=(unsigned char)(sx%256);
  183.         TGA_INI[13]=(unsigned char)(sx/256);
  184.         TGA_INI[14]=(unsigned char)(sy%256);
  185.         TGA_INI[15]=(unsigned char)(sy/256);
  186.         TGA_INI[2]=2;
  187.         TGA_INI[16]=0x18;
  188.         fwrite((char *)&TGA_INI[0],18,1,fp);
  189.         for( a=sy-1;a>=0;a-- )
  190.              {
  191.               for( b=0;b<sx;b++ )
  192.                    {
  193.                     picline[b].r=buf[a][b*bytespixel+2];
  194.                     picline[b].g=buf[a][b*bytespixel+1];
  195.                     picline[b].b=buf[a][b*bytespixel];
  196.                    }
  197.               if (fwrite((char *)picline,sx,3,fp)<3)
  198.                  {
  199.                   fclose(fp);
  200.                   delete picline;
  201.                   return 0;
  202.                  }
  203.              }
  204.         fclose(fp);
  205.        }
  206.     delete picline;
  207.     return 1;
  208. }
  210. void picture::build_icon()
  211. {
  212. if (buf)
  213. {
  214. int sizex,sizey,i;
  215. for( i=0;i<nsizes;i++ )
  216. if (sizes[i]>sx)
  217. break;
  218. if (i<nsizes) i--;
  219. sizex=sizes[i];
  220. for( i=0;i<nsizes;i++ )
  221. if (sizes[i]>sy)
  222. break;
  223. if (i<nsizes) i--;
  224. sizey=sizes[i];
  226. int x,y;
  227. icon=new unsigned char[sizex*sizey*bytespixel];
  228. unsigned char *p=icon;
  230. float dx,dy;
  231. dx=(float)sx/sizex;
  232. dy=(float)sy/sizey;
  233. iconsx=sizex;
  234. iconsy=sizey;
  236. for( y=0;y<sizey;y++ )
  237. for( x=0;x<sizex;x++ )
  238. if (bytespixel==3)
  239. {
  240. *(p++)=buf[(int)(y*dy)][(int)(x*dx)*bytespixel];
  241. *(p++)=buf[(int)(y*dy)][(int)(x*dx)*bytespixel+1];
  242. *(p++)=buf[(int)(y*dy)][(int)(x*dx)*bytespixel+2];
  243. }
  244. else *(p++)=buf[(int)(y*dy)][(int)(x*dx)];
  245. }
  246. }
  248. int picture::LoadBMP(char *name)
  249. {
  250. FILE *fp;
  251. int a,flag=0,wx;
  252. unsigned char *c;
  253. BITMAPFILEHEADER bmfh;
  254. struct { BITMAPINFOHEADER bmih;
  255. RGBQUAD bmcolors[256];
  256. } bmi;
  258. if ((fp=fopen(name,"rb"))!=0)
  259. {
  260. fread((char *)&bmfh,14,1,fp);          // sizeof(bmfh)==14
  261. fread((char *)&bmi,40,1,fp);           // sizeof(BITMAPINFOHEADER)==40
  263. if (bmi.bmih.biPlanes!=1||bmi.bmih.biCompression!=0||bmi.bmih.biBitCount!=8)
  264. {
  265. fclose(fp);
  266. return 0;
  267. }
  268. FreePicture();
  270. c=(unsigned char *)&bmi;
  271. sx=c[4]+256*c[5];
  272. sy=c[8]+256*c[9];
  273. bytespixel=1;
  274. fread((char *)&bmi.bmcolors[0],256,4,fp);
  275. CreatePicture8(sx,sy,256);
  277. for( a=0;a<256;a++ )
  278. {
  279. pal[a].r=bmi.bmcolors[a].rgbRed;
  280. pal[a].g=bmi.bmcolors[a].rgbGreen;
  281. pal[a].b=bmi.bmcolors[a].rgbBlue;
  282. }
  283. wx=(int)(bmi.bmih.biSizeImage/sy);
  285. for( a=sy-1;a>=0;a-- )
  286. fread( (char *)buf[a],wx,1,fp );
  287. fclose(fp);
  289. build_icon();
  290. return 1;
  291. }
  292. return 0;
  293. }
  296. int picture::LoadJPG(char *name)
  297. {
  298. FreePicture();
  299. JPEGDATA data;
  300. FILE *fp;
  301. fp=fopen(name,"rb");
  302. if (fp)
  303. {
  304. memset(&data,0,sizeof(JPEGDATA));
  305. data.input_file = fp;
  306. JpegInfo(&data);
  307. fclose(fp);
  308. if (data.components==3 || data.components==1)
  309. {
  310. bytespixel=data.components;
  311. if (bytespixel==3)
  312. CreatePicture24(data.width,data.height);
  313. else CreatePicture8(data.width,data.height,0);
  315. fp=fopen(name,"rb");
  316. data.ptr             = buf[0];
  317. data.input_file      = fp;
  318. data.hWnd            = 0;
  319. data.ProgressMsg     = 0;
  321. JpegRead(&data);
  322. fclose(fp);
  324. if (data.status==0)
  325. {
  326. build_icon();
  327. return 1;
  328. }
  329. else FreePicture();
  330. }
  331. }
  332. return 0;
  333. }
  335. void picture::ToYIQ()
  336. {
  337. if (bytespixel!=3)
  338. return ;
  339. int x,y;
  340. byteRGB *rgb;
  342. for( y=0;y<sy;y++ )
  343. {
  344. rgb=(byteRGB *)buf[y];
  345. for( x=0;x<sx;x++ )
  346. (rgb++)->ToYIQ();
  347. }
  348. }
  350. void picture::FromYIQ()
  351. {
  352. if (bytespixel!=3)
  353. return ;
  354. int x,y;
  355. byteRGB *rgb;
  357. for( y=0;y<sy;y++ )
  358. {
  359. rgb=(byteRGB *)buf[y];
  360. for( x=0;x<sx;x++ )
  361. (rgb++)->FromYIQ();
  362. }
  363. }
  366. void cor_inter(float xi[3], float yi[3], float c[3][3], float x, float y, byteRGB *rgb)
  367. {
  368. int a;
  369. float v[3][2],m[3][2],n[3];
  371. for( a=0;a<3;a++ )
  372. {
  373. v[a][0]=xi[a];
  374. v[a][1]=yi[a];
  375. }
  377. m[0][0]=x-v[0][0];
  378. m[0][1]=y-v[0][1];
  379. m[1][0]=v[2][0]-v[0][0];
  380. m[1][1]=v[2][1]-v[0][1];
  381. m[2][0]=v[1][0]-v[0][0];
  382. m[2][1]=v[1][1]-v[0][1];
  384. n[0]=m[1][0]*m[2][1]-m[1][1]*m[2][0];
  385. n[1]=m[0][0]*m[2][1]-m[0][1]*m[2][0];
  386. n[2]=m[0][0]*m[1][1]-m[0][1]*m[1][0];
  388. for( a=0;a<3;a++ )
  389. *((&rgb->r)+a)=(unsigned char)(((c[2][a]-c[0][a])*n[1]-(c[1][a]-c[0][a])*n[2])/n[0]+c[0][a]);
  391. }
  393. void picture::GetPixel(int x,int y,byteRGB *rgb)
  394. {
  395. if (buf==0)
  396. return;
  398. x=(x%sx);
  399. y=(y%sy);
  401. if(x<0)
  402. x=sx+x;
  403. if(y<0)
  404. y=sy+y;
  406. if (bytespixel==3)
  407. *rgb=*((byteRGB *)&buf[y][x*3]);
  408. else if (pal)
  409. *rgb=pal[buf[y][x]];
  410. else rgb->r=rgb->g=rgb->b=buf[y][x];
  411. }
  413. #define ROUND(x) ((x)>=0?((int)(x)):((int)(x)-1))
  415. void picture::GetPixel(float x, float y, byteRGB * rgb,int textinterp)
  416. {
  417. if (textinterp==0)
  418. {
  419. GetPixel(ROUND(x), ROUND(y), rgb);
  420. return;
  421. }
  423. float xi[3], yi[3];
  424. float cor[3][3];
  425. int ix=ROUND(x),iy=ROUND(y);
  427. byteRGB rgbt;
  429. if (buf==0)
  430. return;
  432. GetPixel(ix, iy, &rgbt);
  433. cor[2][0]=rgbt.r;
  434. cor[2][1]=rgbt.g;
  435. cor[2][2]=rgbt.b;
  437. GetPixel(ix, iy+1, &rgbt);
  438. cor[2][0]+=rgbt.r;
  439. cor[2][1]+=rgbt.g;
  440. cor[2][2]+=rgbt.b;
  442. GetPixel(ix+1, iy, &rgbt);
  443. cor[2][0]+=rgbt.r;
  444. cor[2][1]+=rgbt.g;
  445. cor[2][2]+=rgbt.b;
  447. GetPixel(ix+1, iy+1, &rgbt);
  448. cor[2][0]+=rgbt.r;
  449. cor[2][1]+=rgbt.g;
  450. cor[2][2]+=rgbt.b;
  452. cor[2][0]/=4;
  453. cor[2][1]/=4;
  454. cor[2][2]/=4;
  456. if((y-iy)>(ix+1-x))
  457. {
  458. xi[0]=(float)(ix+1);
  459. yi[0]=(float)(iy+1);
  460. }
  461. else
  462. {
  463. xi[0]=(float)(ix);
  464. yi[0]=(float)(iy);
  465. }
  467. if((x-ix)>(y-iy))
  468. {
  469. xi[1]=(float)(ix+1);
  470. yi[1]=(float)(iy);
  471. }
  472. else
  473. {
  474. xi[1]=(float)(ix);
  475. yi[1]=(float)(iy+1);
  476. }
  478. GetPixel((int)xi[0], (int)yi[0], &rgbt);
  479. cor[0][0]=rgbt.r;
  480. cor[0][1]=rgbt.g;
  481. cor[0][2]=rgbt.b;
  483. GetPixel((int)xi[1], (int)yi[1], &rgbt);
  484. cor[1][0]=rgbt.r;
  485. cor[1][1]=rgbt.g;
  486. cor[1][2]=rgbt.b;
  488. xi[2]=ix+0.5f;
  489. yi[2]=iy+0.5f;
  491. cor_inter(xi, yi, cor, x, y, rgb);
  492. }