Category

Development Platform
Home > SourceCode/Document > Graph program > View Code
ximadsp.cpp
Package: solidgraph_sources.zip　[view]
Upload User: kairuinn
Upload Date: 2009-02-07
Package Size: 2922k
Code Size: 55k
Category:

Graph program

Development Platform:

Visual C++

ximadsp.cpp：Code Content
  1. // xImaDsp.cpp : DSP functions
  2. /* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
  3.  * CxImage version 5.99a 08/Feb/2004
  4.  */
  6. #include "ximage.h"
  8. #include "ximaiter.h"
  10. #if CXIMAGE_SUPPORT_DSP
  12. ////////////////////////////////////////////////////////////////////////////////
  13. bool CxImage::Threshold(BYTE level)
  14. {
  15. if (!pDib) return false;
  16. if (head.biBitCount == 1) return true;
  18. GrayScale();
  20. CxImage tmp(head.biWidth,head.biHeight,1);
  22. for (long y=0;y<head.biHeight;y++){
  23. info.nProgress = (long)(100*y/head.biHeight);
  24. if (info.nEscape) break;
  25. for (long x=0;x<head.biWidth;x++){
  26. if (GetPixelIndex(x,y)>level)
  27. tmp.SetPixelIndex(x,y,1);
  28. else
  29. tmp.SetPixelIndex(x,y,0);
  30. }
  31. }
  32. tmp.SetPaletteColor(0,0,0,0);
  33. tmp.SetPaletteColor(1,255,255,255);
  34. Transfer(tmp);
  35. return true;
  36. }
  37. ////////////////////////////////////////////////////////////////////////////////
  38. bool CxImage::SplitRGB(CxImage* r,CxImage* g,CxImage* b)
  39. {
  40. if (!pDib) return false;
  41. if (r==NULL && g==NULL && b==NULL) return false;
  43. CxImage tmpr(head.biWidth,head.biHeight,8);
  44. CxImage tmpg(head.biWidth,head.biHeight,8);
  45. CxImage tmpb(head.biWidth,head.biHeight,8);
  47. RGBQUAD color;
  48. for(long y=0; y<head.biHeight; y++){
  49. for(long x=0; x<head.biWidth; x++){
  50. color = GetPixelColor(x,y);
  51. if (r) tmpr.SetPixelIndex(x,y,color.rgbRed);
  52. if (g) tmpg.SetPixelIndex(x,y,color.rgbGreen);
  53. if (b) tmpb.SetPixelIndex(x,y,color.rgbBlue);
  54. }
  55. }
  57. if (r) tmpr.SetGrayPalette();
  58. if (g) tmpg.SetGrayPalette();
  59. if (b) tmpb.SetGrayPalette();
  61. /*for(long j=0; j<256; j++){
  62. BYTE i=(BYTE)j;
  63. if (r) tmpr.SetPaletteColor(i,i,0,0);
  64. if (g) tmpg.SetPaletteColor(i,0,i,0);
  65. if (b) tmpb.SetPaletteColor(i,0,0,i);
  66. }*/
  68. if (r) r->Transfer(tmpr);
  69. if (g) g->Transfer(tmpg);
  70. if (b) b->Transfer(tmpb);
  72. return true;
  73. }
  74. ////////////////////////////////////////////////////////////////////////////////
  75. bool CxImage::SplitCMYK(CxImage* c,CxImage* m,CxImage* y,CxImage* k)
  76. {
  77. if (!pDib) return false;
  78. if (c==NULL && m==NULL && y==NULL && k==NULL) return false;
  80. CxImage tmpc(head.biWidth,head.biHeight,8);
  81. CxImage tmpm(head.biWidth,head.biHeight,8);
  82. CxImage tmpy(head.biWidth,head.biHeight,8);
  83. CxImage tmpk(head.biWidth,head.biHeight,8);
  85. RGBQUAD color;
  86. for(long yy=0; yy<head.biHeight; yy++){
  87. for(long xx=0; xx<head.biWidth; xx++){
  88. color = GetPixelColor(xx,yy);
  89. if (c) tmpc.SetPixelIndex(xx,yy,(BYTE)(255-color.rgbRed));
  90. if (m) tmpm.SetPixelIndex(xx,yy,(BYTE)(255-color.rgbGreen));
  91. if (y) tmpy.SetPixelIndex(xx,yy,(BYTE)(255-color.rgbBlue));
  92. if (k) tmpk.SetPixelIndex(xx,yy,(BYTE)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue));
  93. }
  94. }
  96. if (c) tmpc.SetGrayPalette();
  97. if (m) tmpm.SetGrayPalette();
  98. if (y) tmpy.SetGrayPalette();
  99. if (k) tmpk.SetGrayPalette();
  101. if (c) c->Transfer(tmpc);
  102. if (m) m->Transfer(tmpm);
  103. if (y) y->Transfer(tmpy);
  104. if (k) k->Transfer(tmpk);
  106. return true;
  107. }
  108. ////////////////////////////////////////////////////////////////////////////////
  109. bool CxImage::SplitYUV(CxImage* y,CxImage* u,CxImage* v)
  110. {
  111. if (!pDib) return false;
  112. if (y==NULL && u==NULL && v==NULL) return false;
  114. CxImage tmpy(head.biWidth,head.biHeight,8);
  115. CxImage tmpu(head.biWidth,head.biHeight,8);
  116. CxImage tmpv(head.biWidth,head.biHeight,8);
  118. RGBQUAD color;
  119. for(long yy=0; yy<head.biHeight; yy++){
  120. for(long x=0; x<head.biWidth; x++){
  121. color = RGBtoYUV(GetPixelColor(x,yy));
  122. if (y) tmpy.SetPixelIndex(x,yy,color.rgbRed);
  123. if (u) tmpu.SetPixelIndex(x,yy,color.rgbGreen);
  124. if (v) tmpv.SetPixelIndex(x,yy,color.rgbBlue);
  125. }
  126. }
  128. if (y) tmpy.SetGrayPalette();
  129. if (u) tmpu.SetGrayPalette();
  130. if (v) tmpv.SetGrayPalette();
  132. if (y) y->Transfer(tmpy);
  133. if (u) u->Transfer(tmpu);
  134. if (v) v->Transfer(tmpv);
  136. return true;
  137. }
  138. ////////////////////////////////////////////////////////////////////////////////
  139. bool CxImage::SplitYIQ(CxImage* y,CxImage* i,CxImage* q)
  140. {
  141. if (!pDib) return false;
  142. if (y==NULL && i==NULL && q==NULL) return false;
  144. CxImage tmpy(head.biWidth,head.biHeight,8);
  145. CxImage tmpi(head.biWidth,head.biHeight,8);
  146. CxImage tmpq(head.biWidth,head.biHeight,8);
  148. RGBQUAD color;
  149. for(long yy=0; yy<head.biHeight; yy++){
  150. for(long x=0; x<head.biWidth; x++){
  151. color = RGBtoYIQ(GetPixelColor(x,yy));
  152. if (y) tmpy.SetPixelIndex(x,yy,color.rgbRed);
  153. if (i) tmpi.SetPixelIndex(x,yy,color.rgbGreen);
  154. if (q) tmpq.SetPixelIndex(x,yy,color.rgbBlue);
  155. }
  156. }
  158. if (y) tmpy.SetGrayPalette();
  159. if (i) tmpi.SetGrayPalette();
  160. if (q) tmpq.SetGrayPalette();
  162. if (y) y->Transfer(tmpy);
  163. if (i) i->Transfer(tmpi);
  164. if (q) q->Transfer(tmpq);
  166. return true;
  167. }
  168. ////////////////////////////////////////////////////////////////////////////////
  169. bool CxImage::SplitXYZ(CxImage* x,CxImage* y,CxImage* z)
  170. {
  171. if (!pDib) return false;
  172. if (x==NULL && y==NULL && z==NULL) return false;
  174. CxImage tmpx(head.biWidth,head.biHeight,8);
  175. CxImage tmpy(head.biWidth,head.biHeight,8);
  176. CxImage tmpz(head.biWidth,head.biHeight,8);
  178. RGBQUAD color;
  179. for(long yy=0; yy<head.biHeight; yy++){
  180. for(long xx=0; xx<head.biWidth; xx++){
  181. color = RGBtoXYZ(GetPixelColor(xx,yy));
  182. if (x) tmpx.SetPixelIndex(xx,yy,color.rgbRed);
  183. if (y) tmpy.SetPixelIndex(xx,yy,color.rgbGreen);
  184. if (z) tmpz.SetPixelIndex(xx,yy,color.rgbBlue);
  185. }
  186. }
  188. if (x) tmpx.SetGrayPalette();
  189. if (y) tmpy.SetGrayPalette();
  190. if (z) tmpz.SetGrayPalette();
  192. if (x) x->Transfer(tmpx);
  193. if (y) y->Transfer(tmpy);
  194. if (z) z->Transfer(tmpz);
  196. return true;
  197. }////////////////////////////////////////////////////////////////////////////////
  198. bool CxImage::SplitHSL(CxImage* h,CxImage* s,CxImage* l)
  199. {
  200. if (!pDib) return false;
  201. if (h==NULL && s==NULL && l==NULL) return false;
  203. CxImage tmph(head.biWidth,head.biHeight,8);
  204. CxImage tmps(head.biWidth,head.biHeight,8);
  205. CxImage tmpl(head.biWidth,head.biHeight,8);
  207. RGBQUAD color;
  208. for(long y=0; y<head.biHeight; y++){
  209. for(long x=0; x<head.biWidth; x++){
  210. color = RGBtoHSL(GetPixelColor(x,y));
  211. if (h) tmph.SetPixelIndex(x,y,color.rgbRed);
  212. if (s) tmps.SetPixelIndex(x,y,color.rgbGreen);
  213. if (l) tmpl.SetPixelIndex(x,y,color.rgbBlue);
  214. }
  215. }
  217. if (h) tmph.SetGrayPalette();
  218. if (s) tmps.SetGrayPalette();
  219. if (l) tmpl.SetGrayPalette();
  221. /* pseudo-color generator for hue channel (visual debug)
  222. if (h) for(long j=0; j<256; j++){
  223. BYTE i=(BYTE)j;
  224. RGBQUAD hsl={120,240,i,0};
  225. tmph.SetPaletteColor(i,HSLtoRGB(hsl));
  226. }*/
  228. if (h) h->Transfer(tmph);
  229. if (s) s->Transfer(tmps);
  230. if (l) l->Transfer(tmpl);
  232. return true;
  233. }
  234. ////////////////////////////////////////////////////////////////////////////////
  235. #define  HSLMAX   255 /* H,L, and S vary over 0-HSLMAX */
  236. #define  RGBMAX   255   /* R,G, and B vary over 0-RGBMAX */
  237.                         /* HSLMAX BEST IF DIVISIBLE BY 6 */
  238.                         /* RGBMAX, HSLMAX must each fit in a BYTE. */
  239. /* Hue is undefined if Saturation is 0 (grey-scale) */
  240. /* This value determines where the Hue scrollbar is */
  241. /* initially set for achromatic colors */
  242. #define UNDEFINED (HSLMAX*2/3)
  243. ////////////////////////////////////////////////////////////////////////////////
  244. RGBQUAD CxImage::RGBtoHSL(RGBQUAD lRGBColor)
  245. {
  246. BYTE R,G,B; /* input RGB values */
  247. BYTE H,L,S; /* output HSL values */
  248. BYTE cMax,cMin; /* max and min RGB values */
  249. WORD Rdelta,Gdelta,Bdelta; /* intermediate value: % of spread from max*/
  251. R = lRGBColor.rgbRed; /* get R, G, and B out of DWORD */
  252. G = lRGBColor.rgbGreen;
  253. B = lRGBColor.rgbBlue;
  255. cMax = max( max(R,G), B); /* calculate lightness */
  256. cMin = min( min(R,G), B);
  257. L = (BYTE)((((cMax+cMin)*HSLMAX)+RGBMAX)/(2*RGBMAX));
  259. if (cMax==cMin){ /* r=g=b --> achromatic case */
  260. S = 0; /* saturation */
  261. H = UNDEFINED; /* hue */
  262. } else { /* chromatic case */
  263. if (L <= (HSLMAX/2)) /* saturation */
  264. S = (BYTE)((((cMax-cMin)*HSLMAX)+((cMax+cMin)/2))/(cMax+cMin));
  265. else
  266. S = (BYTE)((((cMax-cMin)*HSLMAX)+((2*RGBMAX-cMax-cMin)/2))/(2*RGBMAX-cMax-cMin));
  267. /* hue */
  268. Rdelta = (WORD)((((cMax-R)*(HSLMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin));
  269. Gdelta = (WORD)((((cMax-G)*(HSLMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin));
  270. Bdelta = (WORD)((((cMax-B)*(HSLMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin));
  272. if (R == cMax)
  273. H = (BYTE)(Bdelta - Gdelta);
  274. else if (G == cMax)
  275. H = (BYTE)((HSLMAX/3) + Rdelta - Bdelta);
  276. else /* B == cMax */
  277. H = (BYTE)(((2*HSLMAX)/3) + Gdelta - Rdelta);
  279. // if (H < 0) H += HSLMAX;     //always false
  280. if (H > HSLMAX) H -= HSLMAX;
  281. }
  282. RGBQUAD hsl={L,S,H,0};
  283. return hsl;
  284. }
  285. ////////////////////////////////////////////////////////////////////////////////
  286. float CxImage::HueToRGB(float n1,float n2, float hue)
  287. {
  288. //<F. Livraghi> fixed implementation for HSL2RGB routine
  289. float rValue;
  291. if (hue > 360)
  292. hue = hue - 360;
  293. else if (hue < 0)
  294. hue = hue + 360;
  296. if (hue < 60)
  297. rValue = n1 + (n2-n1)*hue/60.0f;
  298. else if (hue < 180)
  299. rValue = n2;
  300. else if (hue < 240)
  301. rValue = n1+(n2-n1)*(240-hue)/60;
  302. else
  303. rValue = n1;
  305. return rValue;
  306. }
  307. ////////////////////////////////////////////////////////////////////////////////
  308. RGBQUAD CxImage::HSLtoRGB(COLORREF cHSLColor)
  309. {
  310. return HSLtoRGB(RGBtoRGBQUAD(cHSLColor));
  311. }
  312. ////////////////////////////////////////////////////////////////////////////////
  313. RGBQUAD CxImage::HSLtoRGB(RGBQUAD lHSLColor)
  314. { 
  315. //<F. Livraghi> fixed implementation for HSL2RGB routine
  316. float h,s,l;
  317. float m1,m2;
  318. BYTE r,g,b;
  320. h = (float)lHSLColor.rgbRed * 360.0f/255.0f;
  321. s = (float)lHSLColor.rgbGreen/255.0f;
  322. l = (float)lHSLColor.rgbBlue/255.0f;
  324. if (l <= 0.5) m2 = l * (1+s);
  325. else m2 = l + s - l*s;
  327. m1 = 2 * l - m2;
  329. if (s == 0) {
  330. r=g=b=(BYTE)(l*255.0f);
  331. } else {
  332. r = (BYTE)(HueToRGB(m1,m2,h+120) * 255.0f);
  333. g = (BYTE)(HueToRGB(m1,m2,h) * 255.0f);
  334. b = (BYTE)(HueToRGB(m1,m2,h-120) * 255.0f);
  335. }
  337. RGBQUAD rgb = {b,g,r,0};
  338. return rgb;
  339. }
  340. ////////////////////////////////////////////////////////////////////////////////
  341. RGBQUAD CxImage::YUVtoRGB(RGBQUAD lYUVColor)
  342. {
  343. int U,V,R,G,B;
  344. float Y = lYUVColor.rgbRed;
  345. U = lYUVColor.rgbGreen - 128;
  346. V = lYUVColor.rgbBlue - 128;
  348. // R = (int)(1.164 * Y + 2.018 * U);
  349. // G = (int)(1.164 * Y - 0.813 * V - 0.391 * U);
  350. // B = (int)(1.164 * Y + 1.596 * V);
  351. R = (int)( Y + 1.403f * V);
  352. G = (int)( Y - 0.344f * U - 0.714f * V);
  353. B = (int)( Y + 1.770f * U);
  355. R= min(255,max(0,R));
  356. G= min(255,max(0,G));
  357. B= min(255,max(0,B));
  358. RGBQUAD rgb={(BYTE)B,(BYTE)G,(BYTE)R,0};
  359. return rgb;
  360. }
  361. ////////////////////////////////////////////////////////////////////////////////
  362. RGBQUAD CxImage::RGBtoYUV(RGBQUAD lRGBColor)
  363. {
  364. int Y,U,V,R,G,B;
  365. R = lRGBColor.rgbRed;
  366. G = lRGBColor.rgbGreen;
  367. B = lRGBColor.rgbBlue;
  369. // Y = (int)( 0.257 * R + 0.504 * G + 0.098 * B);
  370. // U = (int)( 0.439 * R - 0.368 * G - 0.071 * B + 128);
  371. // V = (int)(-0.148 * R - 0.291 * G + 0.439 * B + 128);
  372. Y = (int)(0.299f * R + 0.587f * G + 0.114f * B);
  373. U = (int)((B-Y) * 0.565f + 128);
  374. V = (int)((R-Y) * 0.713f + 128);
  376. Y= min(255,max(0,Y));
  377. U= min(255,max(0,U));
  378. V= min(255,max(0,V));
  379. RGBQUAD yuv={(BYTE)V,(BYTE)U,(BYTE)Y,0};
  380. return yuv;
  381. }
  382. ////////////////////////////////////////////////////////////////////////////////
  383. RGBQUAD CxImage::YIQtoRGB(RGBQUAD lYIQColor)
  384. {
  385. int I,Q,R,G,B;
  386. float Y = lYIQColor.rgbRed;
  387. I = lYIQColor.rgbGreen - 128;
  388. Q = lYIQColor.rgbBlue - 128;
  390. R = (int)( Y + 0.956f * I + 0.621f * Q);
  391. G = (int)( Y - 0.273f * I - 0.647f * Q);
  392. B = (int)( Y - 1.104f * I + 1.701f * Q);
  394. R= min(255,max(0,R));
  395. G= min(255,max(0,G));
  396. B= min(255,max(0,B));
  397. RGBQUAD rgb={(BYTE)B,(BYTE)G,(BYTE)R,0};
  398. return rgb;
  399. }
  400. ////////////////////////////////////////////////////////////////////////////////
  401. RGBQUAD CxImage::RGBtoYIQ(RGBQUAD lRGBColor)
  402. {
  403. int Y,I,Q,R,G,B;
  404. R = lRGBColor.rgbRed;
  405. G = lRGBColor.rgbGreen;
  406. B = lRGBColor.rgbBlue;
  408. Y = (int)( 0.2992f * R + 0.5868f * G + 0.1140f * B);
  409. I = (int)( 0.5960f * R - 0.2742f * G - 0.3219f * B + 128);
  410. Q = (int)( 0.2109f * R - 0.5229f * G + 0.3120f * B + 128);
  412. Y= min(255,max(0,Y));
  413. I= min(255,max(0,I));
  414. Q= min(255,max(0,Q));
  415. RGBQUAD yiq={(BYTE)Q,(BYTE)I,(BYTE)Y,0};
  416. return yiq;
  417. }
  418. ////////////////////////////////////////////////////////////////////////////////
  419. RGBQUAD CxImage::XYZtoRGB(RGBQUAD lXYZColor)
  420. {
  421. int X,Y,Z,R,G,B;
  422. X = lXYZColor.rgbRed;
  423. Y = lXYZColor.rgbGreen;
  424. Z = lXYZColor.rgbBlue;
  425. double k=1.088751;
  427. R = (int)(  3.240479f * X - 1.537150f * Y - 0.498535f * Z * k);
  428. G = (int)( -0.969256f * X + 1.875992f * Y + 0.041556f * Z * k);
  429. B = (int)(  0.055648f * X - 0.204043f * Y + 1.057311f * Z * k);
  431. R= min(255,max(0,R));
  432. G= min(255,max(0,G));
  433. B= min(255,max(0,B));
  434. RGBQUAD rgb={(BYTE)B,(BYTE)G,(BYTE)R,0};
  435. return rgb;
  436. }
  437. ////////////////////////////////////////////////////////////////////////////////
  438. RGBQUAD CxImage::RGBtoXYZ(RGBQUAD lRGBColor)
  439. {
  440. int X,Y,Z,R,G,B;
  441. R = lRGBColor.rgbRed;
  442. G = lRGBColor.rgbGreen;
  443. B = lRGBColor.rgbBlue;
  445. X = (int)( 0.412453f * R + 0.357580f * G + 0.180423f * B);
  446. Y = (int)( 0.212671f * R + 0.715160f * G + 0.072169f * B);
  447. Z = (int)((0.019334f * R + 0.119193f * G + 0.950227f * B)*0.918483657f);
  449. //X= min(255,max(0,X));
  450. //Y= min(255,max(0,Y));
  451. //Z= min(255,max(0,Z));
  452. RGBQUAD xyz={(BYTE)Z,(BYTE)Y,(BYTE)X,0};
  453. return xyz;
  454. }
  455. ////////////////////////////////////////////////////////////////////////////////
  456. void CxImage::HuePalette(float correction)
  457. {
  458. if (head.biClrUsed==0) return;
  460. for(DWORD j=0; j<head.biClrUsed; j++){
  461. BYTE i=(BYTE)(j*correction*(255/(head.biClrUsed-1)));
  462. RGBQUAD hsl={120,240,i,0};
  463. SetPaletteColor((BYTE)j,HSLtoRGB(hsl));
  464. }
  465. }
  466. ////////////////////////////////////////////////////////////////////////////////
  467. bool CxImage::Colorize(BYTE hue, BYTE sat)
  468. {
  469. if (!pDib) return false;
  471. RGBQUAD color;
  472. if (head.biClrUsed==0){
  474. long xmin,xmax,ymin,ymax;
  475. if (pSelection){
  476. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  477. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  478. } else {
  479. xmin = ymin = 0;
  480. xmax = head.biWidth; ymax=head.biHeight;
  481. }
  483. for(long y=ymin; y<ymax; y++){
  484. for(long x=xmin; x<xmax; x++){
  485. #if CXIMAGE_SUPPORT_SELECTION
  486. if (SelectionIsInside(x,y))
  487. #endif //CXIMAGE_SUPPORT_SELECTION
  488. {
  489. color = RGBtoHSL(GetPixelColor(x,y));
  490. color.rgbRed=hue;
  491. color.rgbGreen=sat;
  492. SetPixelColor(x,y,HSLtoRGB(color));
  493. }
  494. }
  495. }
  496. } else {
  497. for(DWORD j=0; j<head.biClrUsed; j++){
  498. color = RGBtoHSL(GetPaletteColor((BYTE)j));
  499. color.rgbRed=hue;
  500. color.rgbGreen=sat;
  501. SetPaletteColor((BYTE)j,HSLtoRGB(color));
  502. }
  503. }
  505. return true;
  506. }
  507. ////////////////////////////////////////////////////////////////////////////////
  508. bool CxImage::Light(long brightness, long contrast)
  509. {
  510. if (!pDib) return false;
  511. float c=(100 + contrast)/100.0f;
  512. brightness+=128;
  514. BYTE cTable[256]; //<nipper>
  515. for (int i=0;i<256;i++) {
  516. cTable[i] = (BYTE)max(0,min(255,(int)((i-128)*c + brightness)));
  517. }
  519. return Lut(cTable);
  520. }
  521. ////////////////////////////////////////////////////////////////////////////////
  522. float CxImage::Mean()
  523. {
  524. if (!pDib) return 0;
  525. CxImage tmp(*this,true);
  526. tmp.GrayScale();
  527. float sum=0;
  529. long xmin,xmax,ymin,ymax;
  530. if (pSelection){
  531. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  532. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  533. } else {
  534. xmin = ymin = 0;
  535. xmax = head.biWidth; ymax=head.biHeight;
  536. }
  537. if (xmin==xmax || ymin==ymax) return (float)0.0;
  539. BYTE *iSrc=tmp.info.pImage;
  540. for(long y=ymin; y<ymax; y++){
  541. info.nProgress = (long)(100*y/ymax); //<Anatoly Ivasyuk>
  542. for(long x=xmin; x<xmax; x++){
  543. sum+=iSrc[x];
  544. }
  545. iSrc+=tmp.info.dwEffWidth;
  546. }
  547. return sum/(xmax-xmin)/(ymax-ymin);
  548. }
  549. ////////////////////////////////////////////////////////////////////////////////
  550. bool CxImage::Filter(long* kernel, long Ksize, long Kfactor, long Koffset)
  551. {
  552. if (!pDib) return false;
  554. long k2 = Ksize/2;
  555. long kmax= Ksize-k2;
  556. long r,g,b,i;
  557. RGBQUAD c;
  558. CxImage tmp(*this,pSelection!=0,true,true);
  561. long xmin,xmax,ymin,ymax;
  562. if (pSelection){
  563. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  564. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  565. } else {
  566. xmin = ymin = 0;
  567. xmax = head.biWidth; ymax=head.biHeight;
  568. }
  570. if ((head.biBitCount==8) && IsGrayScale())
  571. {
  572. unsigned char* cPtr;
  573. unsigned char* cPtr2;      
  574. int iCount;
  575. int iY, iY2, iY1;
  576. cPtr = info.pImage;
  577. cPtr2 = (unsigned char *)tmp.info.pImage;
  578. if (Kfactor==0) Kfactor = 1;
  579. for(long y=ymin; y<ymax; y++){
  580. info.nProgress = (long)(100*y/head.biHeight);
  581. if (info.nEscape) break;
  582. for(long x=xmin; x<xmax; x++){
  583. iY1 = y*info.dwEffWidth+x;
  584. #if CXIMAGE_SUPPORT_SELECTION
  585. if (SelectionIsInside(x,y))
  586. #endif //CXIMAGE_SUPPORT_SELECTION
  587. {
  588. if (y-k2 > 0 && (y+kmax-1) < head.biHeight && x-k2 > 0 && (x+kmax-1) < head.biWidth)
  589. {
  590. b=0;
  591. iCount = 0;
  592. iY2 = ((y-k2)*info.dwEffWidth);
  593. for(long j=-k2;j<kmax;j++)
  594. {
  595. iY = iY2+x;
  596. for(long k=-k2;k<kmax;k++)
  597. {
  598. i=kernel[iCount];
  599. b += cPtr[iY+k] * i;
  600. iCount++;
  601. }
  602. iY2 += info.dwEffWidth;
  603. }
  604. cPtr2[iY1] = (BYTE)min(255, max(0,(int)(b/Kfactor + Koffset)));
  605. }
  606. else
  607. cPtr2[iY1] = cPtr[iY1];
  608. }
  609. }
  610. }
  611. }
  612. else
  613. {
  614. for(long y=ymin; y<ymax; y++){
  615. info.nProgress = (long)(100*y/head.biHeight);
  616. if (info.nEscape) break;
  617. for(long x=xmin; x<xmax; x++){
  618. #if CXIMAGE_SUPPORT_SELECTION
  619. if (SelectionIsInside(x,y))
  620. #endif //CXIMAGE_SUPPORT_SELECTION
  621. {
  622. r=b=g=0;
  623. for(long j=-k2;j<kmax;j++){
  624. for(long k=-k2;k<kmax;k++){
  625. c=GetPixelColor(x+j,y+k);
  626. i=kernel[(j+k2)+Ksize*(k+k2)];
  627. r += c.rgbRed * i;
  628. g += c.rgbGreen * i;
  629. b += c.rgbBlue * i;
  630. }
  631. }
  632. if (Kfactor==0){
  633. c.rgbRed   = (BYTE)min(255, max(0,(int)(r + Koffset)));
  634. c.rgbGreen = (BYTE)min(255, max(0,(int)(g + Koffset)));
  635. c.rgbBlue  = (BYTE)min(255, max(0,(int)(b + Koffset)));
  636. } else {
  637. c.rgbRed   = (BYTE)min(255, max(0,(int)(r/Kfactor + Koffset)));
  638. c.rgbGreen = (BYTE)min(255, max(0,(int)(g/Kfactor + Koffset)));
  639. c.rgbBlue  = (BYTE)min(255, max(0,(int)(b/Kfactor + Koffset)));
  640. }
  641. tmp.SetPixelColor(x,y,c);
  642. }
  643. }
  644. }
  645. }
  646. Transfer(tmp);
  647. return true;
  648. }
  649. ////////////////////////////////////////////////////////////////////////////////
  650. bool CxImage::Erode(long Ksize)
  651. {
  652. if (!pDib) return false;
  654. long k2 = Ksize/2;
  655. long kmax= Ksize-k2;
  656. BYTE r,g,b;
  657. RGBQUAD c;
  658. CxImage tmp(*this,pSelection!=0,true,true);
  660. long xmin,xmax,ymin,ymax;
  661. if (pSelection){
  662. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  663. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  664. } else {
  665. xmin = ymin = 0;
  666. xmax = head.biWidth; ymax=head.biHeight;
  667. }
  669. for(long y=ymin; y<ymax; y++){
  670. info.nProgress = (long)(100*y/head.biHeight);
  671. if (info.nEscape) break;
  672. for(long x=xmin; x<xmax; x++){
  673. #if CXIMAGE_SUPPORT_SELECTION
  674. if (SelectionIsInside(x,y))
  675. #endif //CXIMAGE_SUPPORT_SELECTION
  676. {
  677. r=b=g=255;
  678. for(long j=-k2;j<kmax;j++){
  679. for(long k=-k2;k<kmax;k++){
  680. c=GetPixelColor(x+j,y+k);
  681. if (c.rgbRed < r) r=c.rgbRed;
  682. if (c.rgbGreen < g) g=c.rgbGreen;
  683. if (c.rgbBlue < b) b=c.rgbBlue;
  684. }
  685. }
  686. c.rgbRed   = r;
  687. c.rgbGreen = g;
  688. c.rgbBlue  = b;
  689. tmp.SetPixelColor(x,y,c);
  690. }
  691. }
  692. }
  693. Transfer(tmp);
  694. return true;
  695. }
  696. ////////////////////////////////////////////////////////////////////////////////
  697. bool CxImage::Dilate(long Ksize)
  698. {
  699. if (!pDib) return false;
  701. long k2 = Ksize/2;
  702. long kmax= Ksize-k2;
  703. BYTE r,g,b;
  704. RGBQUAD c;
  705. CxImage tmp(*this,pSelection!=0,true,true);
  707. long xmin,xmax,ymin,ymax;
  708. if (pSelection){
  709. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  710. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  711. } else {
  712. xmin = ymin = 0;
  713. xmax = head.biWidth; ymax=head.biHeight;
  714. }
  716. for(long y=ymin; y<ymax; y++){
  717. info.nProgress = (long)(100*y/head.biHeight);
  718. if (info.nEscape) break;
  719. for(long x=xmin; x<xmax; x++){
  720. #if CXIMAGE_SUPPORT_SELECTION
  721. if (SelectionIsInside(x,y))
  722. #endif //CXIMAGE_SUPPORT_SELECTION
  723. {
  724. r=b=g=0;
  725. for(long j=-k2;j<kmax;j++){
  726. for(long k=-k2;k<kmax;k++){
  727. c=GetPixelColor(x+j,y+k);
  728. if (c.rgbRed > r) r=c.rgbRed;
  729. if (c.rgbGreen > g) g=c.rgbGreen;
  730. if (c.rgbBlue > b) b=c.rgbBlue;
  731. }
  732. }
  733. c.rgbRed   = r;
  734. c.rgbGreen = g;
  735. c.rgbBlue  = b;
  736. tmp.SetPixelColor(x,y,c);
  737. }
  738. }
  739. }
  740. Transfer(tmp);
  741. return true;
  743. }
  744. ////////////////////////////////////////////////////////////////////////////////
  745. // thanks to Mwolski <mpwolski(at)hotmail(dot)com>
  746. void CxImage::Mix(CxImage & imgsrc2, ImageOpType op, long lXOffset, long lYOffset)
  747. {
  748.     long lWide = min(GetWidth(),imgsrc2.GetWidth()-lXOffset);
  749.     long lHeight = min(GetHeight(),imgsrc2.GetHeight()-lYOffset);
  751.     RGBQUAD rgbBackgrnd = GetTransColor();
  752.     RGBQUAD rgb1, rgb2, rgbDest;
  754.     for(long lY=0;lY<lHeight;lY++)
  755.     {
  756. info.nProgress = (long)(100*lY/head.biHeight);
  757. if (info.nEscape) break;
  759.         for(long lX=0;lX<lWide;lX++)
  760.         {
  761. #if CXIMAGE_SUPPORT_SELECTION
  762. if (SelectionIsInside(lX,lY) && imgsrc2.SelectionIsInside(lX+lXOffset,lY+lYOffset))
  763. #endif //CXIMAGE_SUPPORT_SELECTION
  764. {
  765. rgb1 = GetPixelColor(lX,lY);
  766. rgb2 = imgsrc2.GetPixelColor(lX+lXOffset,lY+lYOffset);
  767. switch(op)
  768. {
  769. case OpAdd:
  770. rgbDest.rgbBlue = (BYTE)max(0,min(255,rgb1.rgbBlue+rgb2.rgbBlue));
  771. rgbDest.rgbGreen = (BYTE)max(0,min(255,rgb1.rgbGreen+rgb2.rgbGreen));
  772. rgbDest.rgbRed = (BYTE)max(0,min(255,rgb1.rgbRed+rgb2.rgbRed));
  773. break;
  774. case OpSub:
  775. rgbDest.rgbBlue = (BYTE)max(0,min(255,rgb1.rgbBlue-rgb2.rgbBlue));
  776. rgbDest.rgbGreen = (BYTE)max(0,min(255,rgb1.rgbGreen-rgb2.rgbGreen));
  777. rgbDest.rgbRed = (BYTE)max(0,min(255,rgb1.rgbRed-rgb2.rgbRed));
  778. break;
  779. case OpAnd:
  780. rgbDest.rgbBlue = (BYTE)(rgb1.rgbBlue&rgb2.rgbBlue);
  781. rgbDest.rgbGreen = (BYTE)(rgb1.rgbGreen&rgb2.rgbGreen);
  782. rgbDest.rgbRed = (BYTE)(rgb1.rgbRed&rgb2.rgbRed);
  783. break;
  784. case OpXor:
  785. rgbDest.rgbBlue = (BYTE)(rgb1.rgbBlue^rgb2.rgbBlue);
  786. rgbDest.rgbGreen = (BYTE)(rgb1.rgbGreen^rgb2.rgbGreen);
  787. rgbDest.rgbRed = (BYTE)(rgb1.rgbRed^rgb2.rgbRed);
  788. break;
  789. case OpOr:
  790. rgbDest.rgbBlue = (BYTE)(rgb1.rgbBlue|rgb2.rgbBlue);
  791. rgbDest.rgbGreen = (BYTE)(rgb1.rgbGreen|rgb2.rgbGreen);
  792. rgbDest.rgbRed = (BYTE)(rgb1.rgbRed|rgb2.rgbRed);
  793. break;
  794. case OpMask:
  795. if(rgb2.rgbBlue==0 && rgb2.rgbGreen==0 && rgb2.rgbRed==0)
  796. rgbDest = rgbBackgrnd;
  797. else
  798. rgbDest = rgb1;
  799. break;
  800. case OpSrcCopy:
  801. if(memcmp(&rgb1,&rgbBackgrnd,sizeof(RGBQUAD))==0)
  802. rgbDest = rgb2;
  803. else // copy straight over
  804. rgbDest = rgb1;
  805. break;
  806. case OpDstCopy:
  807. if(memcmp(&rgb2,&rgbBackgrnd,sizeof(RGBQUAD))==0)
  808. rgbDest = rgb1;
  809. else // copy straight over
  810. rgbDest = rgb2;
  811. break;
  812. case OpSrcBlend:
  813. if(memcmp(&rgb1,&rgbBackgrnd,sizeof(RGBQUAD))==0)
  814. rgbDest = rgb2;
  815. else
  816. {
  817. long lBDiff = abs(rgb1.rgbBlue - rgbBackgrnd.rgbBlue);
  818. long lGDiff = abs(rgb1.rgbGreen - rgbBackgrnd.rgbGreen);
  819. long lRDiff = abs(rgb1.rgbRed - rgbBackgrnd.rgbRed);
  821. double lAverage = (lBDiff+lGDiff+lRDiff)/3;
  822. double lThresh = 16;
  823. double dLarge = lAverage/lThresh;
  824. double dSmall = (lThresh-lAverage)/lThresh;
  825. double dSmallAmt = dSmall*((double)rgb2.rgbBlue);
  827. if( lAverage < lThresh+1){
  828. rgbDest.rgbBlue = (BYTE)max(0,min(255,(int)(dLarge*((double)rgb1.rgbBlue) +
  829. dSmallAmt)));
  830. rgbDest.rgbGreen = (BYTE)max(0,min(255,(int)(dLarge*((double)rgb1.rgbGreen) +
  831. dSmallAmt)));
  832. rgbDest.rgbRed = (BYTE)max(0,min(255,(int)(dLarge*((double)rgb1.rgbRed) +
  833. dSmallAmt)));
  834. }
  835. else
  836. rgbDest = rgb1;
  837. }
  838. break;
  839. default:
  840. return;
  841. }
  842. SetPixelColor(lX,lY,rgbDest);
  843. }
  844. }
  845. }
  846. }
  847. ////////////////////////////////////////////////////////////////////////////////
  848. // thanks to Kenneth Ballard
  849. void CxImage::MixFrom(CxImage & imagesrc2, long lXOffset, long lYOffset)
  850. {
  851.     RGBQUAD rgbBackgrnd = imagesrc2.GetTransColor();
  852.     RGBQUAD rgb1;
  854.     long width = imagesrc2.GetWidth();
  855.     long height = imagesrc2.GetHeight();
  857.     int x, y;
  859.     for(x = 0; x < width; x++)
  860.     {
  861.         for(y = 0; y < height; y++)
  862.         {
  863.             rgb1 = imagesrc2.GetPixelColor(x, y);
  864.             if(memcmp(&rgb1, &rgbBackgrnd, sizeof(RGBQUAD)) != 0)
  865.                 SetPixelColor(x + lXOffset, y + lYOffset, rgb1);
  866.         }
  867.     }
  868. }
  869. ////////////////////////////////////////////////////////////////////////////////
  870. bool CxImage::ShiftRGB(long r, long g, long b)
  871. {
  872. if (!pDib) return false;
  873. RGBQUAD color;
  874. if (head.biClrUsed==0){
  876. long xmin,xmax,ymin,ymax;
  877. if (pSelection){
  878. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  879. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  880. } else {
  881. xmin = ymin = 0;
  882. xmax = head.biWidth; ymax=head.biHeight;
  883. }
  885. for(long y=ymin; y<ymax; y++){
  886. for(long x=xmin; x<xmax; x++){
  887. #if CXIMAGE_SUPPORT_SELECTION
  888. if (SelectionIsInside(x,y))
  889. #endif //CXIMAGE_SUPPORT_SELECTION
  890. {
  891. color = GetPixelColor(x,y);
  892. color.rgbRed = (BYTE)max(0,min(255,(int)(color.rgbRed + r)));
  893. color.rgbGreen = (BYTE)max(0,min(255,(int)(color.rgbGreen + g)));
  894. color.rgbBlue = (BYTE)max(0,min(255,(int)(color.rgbBlue + b)));
  895. SetPixelColor(x,y,color);
  896. }
  897. }
  898. }
  899. } else {
  900. for(DWORD j=0; j<head.biClrUsed; j++){
  901. color = GetPaletteColor((BYTE)j);
  902. color.rgbRed = (BYTE)max(0,min(255,(int)(color.rgbRed + r)));
  903. color.rgbGreen = (BYTE)max(0,min(255,(int)(color.rgbGreen + g)));
  904. color.rgbBlue = (BYTE)max(0,min(255,(int)(color.rgbBlue + b)));
  905. SetPaletteColor((BYTE)j,color);
  906. }
  907. }
  908. return true;
  909. }
  910. ////////////////////////////////////////////////////////////////////////////////
  911. bool CxImage::Gamma(float gamma)
  912. {
  913. if (!pDib) return false;
  915. double dinvgamma = 1/gamma;
  916. double dMax = pow(255.0, dinvgamma) / 255.0;
  918. BYTE cTable[256]; //<nipper>
  919. for (int i=0;i<256;i++) {
  920. cTable[i] = (BYTE)max(0,min(255,(int)( pow((double)i, dinvgamma) / dMax)));
  921. }
  923. return Lut(cTable);
  924. }
  925. ////////////////////////////////////////////////////////////////////////////////
  926. #if CXIMAGE_SUPPORT_WINCE == 0
  927. bool CxImage::Median(long Ksize)
  928. {
  929. if (!pDib) return false;
  931. long k2 = Ksize/2;
  932. long kmax= Ksize-k2;
  933. long i,j,k;
  935. RGBQUAD* kernel = (RGBQUAD*)malloc(Ksize*Ksize*sizeof(RGBQUAD));
  937. CxImage tmp(*this,pSelection!=0,true,true);
  939. long xmin,xmax,ymin,ymax;
  940. if (pSelection){
  941. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  942. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  943. } else {
  944. xmin = ymin = 0;
  945. xmax = head.biWidth; ymax=head.biHeight;
  946. }
  948. for(long y=ymin; y<ymax; y++){
  949. info.nProgress = (long)(100*y/head.biHeight);
  950. if (info.nEscape) break;
  951. for(long x=xmin; x<xmax; x++){
  952. #if CXIMAGE_SUPPORT_SELECTION
  953. if (SelectionIsInside(x,y))
  954. #endif //CXIMAGE_SUPPORT_SELECTION
  955. {
  956. for(j=-k2, i=0;j<kmax;j++)
  957. for(k=-k2;k<kmax;k++, i++)
  958. kernel[i]=GetPixelColor(x+j,y+k);
  960. qsort(kernel, i, sizeof(RGBQUAD), CompareColors);
  961. tmp.SetPixelColor(x,y,kernel[i/2]);
  962. }
  963. }
  964. }
  965. free(kernel);
  966. Transfer(tmp);
  967. return true;
  968. }
  969. #endif //CXIMAGE_SUPPORT_WINCE
  970. ////////////////////////////////////////////////////////////////////////////////
  971. bool CxImage::Noise(long level)
  972. {
  973. if (!pDib) return false;
  974. RGBQUAD color;
  976. long xmin,xmax,ymin,ymax,n;
  977. if (pSelection){
  978. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  979. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  980. } else {
  981. xmin = ymin = 0;
  982. xmax = head.biWidth; ymax=head.biHeight;
  983. }
  985. for(long y=ymin; y<ymax; y++){
  986. info.nProgress = (long)(100*y/ymax); //<Anatoly Ivasyuk>
  987. for(long x=xmin; x<xmax; x++){
  988. #if CXIMAGE_SUPPORT_SELECTION
  989. if (SelectionIsInside(x,y))
  990. #endif //CXIMAGE_SUPPORT_SELECTION
  991. {
  992. color = GetPixelColor(x,y);
  993. n=(long)((rand()/(float)RAND_MAX - 0.5)*level);
  994. color.rgbRed = (BYTE)max(0,min(255,(int)(color.rgbRed + n)));
  995. n=(long)((rand()/(float)RAND_MAX - 0.5)*level);
  996. color.rgbGreen = (BYTE)max(0,min(255,(int)(color.rgbGreen + n)));
  997. n=(long)((rand()/(float)RAND_MAX - 0.5)*level);
  998. color.rgbBlue = (BYTE)max(0,min(255,(int)(color.rgbBlue + n)));
  999. SetPixelColor(x,y,color);
  1000. }
  1001. }
  1002. }
  1003. return true;
  1004. }
  1005. ////////////////////////////////////////////////////////////////////////////////
  1006. #ifndef __BORLANDC__
  1007. ////////////////////////////////////////////////////////////////////////////////
  1008. bool CxImage::FFT2(CxImage* srcReal, CxImage* srcImag, CxImage* dstReal, CxImage* dstImag,
  1009.    long direction, bool bForceFFT, bool bMagnitude)
  1010. {
  1011. //check if there is something to convert
  1012. if (srcReal==NULL && srcImag==NULL) return false;
  1014. long w,h;
  1015. //get width and height
  1016. if (srcReal) {
  1017. w=srcReal->GetWidth();
  1018. h=srcReal->GetHeight();
  1019. } else {
  1020. w=srcImag->GetWidth();
  1021. h=srcImag->GetHeight();
  1022. }
  1024. bool bXpow2 = IsPowerof2(w);
  1025. bool bYpow2 = IsPowerof2(h);
  1026. //if bForceFFT, width AND height must be powers of 2
  1027. if (bForceFFT && !(bXpow2 && bYpow2)) {
  1028. long i;
  1030. i=0;
  1031. while((1<<i)<w) i++;
  1032. w=1<<i;
  1033. bXpow2=true;
  1035. i=0;
  1036. while((1<<i)<h) i++;
  1037. h=1<<i;
  1038. bYpow2=true;
  1039. }
  1041. // I/O images for FFT
  1042. CxImage *tmpReal,*tmpImag;
  1044. // select output
  1045. tmpReal = (dstReal) ? dstReal : srcReal;
  1046. tmpImag = (dstImag) ? dstImag : srcImag;
  1048. // src!=dst -> copy the image
  1049. if (srcReal && dstReal) tmpReal->Copy(*srcReal,true,false,false);
  1050. if (srcImag && dstImag) tmpImag->Copy(*srcImag,true,false,false);
  1052. // dst&&src are empty -> create new one, else turn to GrayScale
  1053. if (srcReal==0 && dstReal==0){
  1054. tmpReal = new CxImage(w,h,8);
  1055. tmpReal->Clear(0);
  1056. tmpReal->SetGrayPalette();
  1057. } else {
  1058. if (!tmpReal->IsGrayScale()) tmpReal->GrayScale();
  1059. }
  1060. if (srcImag==0 && dstImag==0){
  1061. tmpImag = new CxImage(w,h,8);
  1062. tmpImag->Clear(0);
  1063. tmpImag->SetGrayPalette();
  1064. } else {
  1065. if (!tmpImag->IsGrayScale()) tmpImag->GrayScale();
  1066. }
  1068. if (!(tmpReal->IsValid() && tmpImag->IsValid())){
  1069. if (srcReal==0 && dstReal==0) delete tmpReal;
  1070. if (srcImag==0 && dstImag==0) delete tmpImag;
  1071. return false;
  1072. }
  1074. //resample for FFT, if necessary 
  1075. tmpReal->Resample(w,h,0);
  1076. tmpImag->Resample(w,h,0);
  1078. //ok, here we have 2 (w x h), grayscale images ready for a FFT
  1080. double* real;
  1081. double* imag;
  1082. long j,k,m;
  1084. _complex **grid;
  1085. //double mean = tmpReal->Mean();
  1086. /* Allocate memory for the grid */
  1087. grid = (_complex **)malloc(w * sizeof(_complex));
  1088. for (k=0;k<w;k++) {
  1089. grid[k] = (_complex *)malloc(h * sizeof(_complex));
  1090. }
  1091. for (j=0;j<h;j++) {
  1092. for (k=0;k<w;k++) {
  1093. grid[k][j].x = tmpReal->GetPixelIndex(k,j)-128;
  1094. grid[k][j].y = tmpImag->GetPixelIndex(k,j)-128;
  1095. }
  1096. }
  1098. //DFT buffers
  1099. double *real2,*imag2;
  1100. real2 = (double*)malloc(max(w,h) * sizeof(double));
  1101. imag2 = (double*)malloc(max(w,h) * sizeof(double));
  1103. /* Transform the rows */
  1104. real = (double *)malloc(w * sizeof(double));
  1105. imag = (double *)malloc(w * sizeof(double));
  1107. m=0;
  1108. while((1<<m)<w) m++;
  1110. for (j=0;j<h;j++) {
  1111. for (k=0;k<w;k++) {
  1112. real[k] = grid[k][j].x;
  1113. imag[k] = grid[k][j].y;
  1114. }
  1116. if (bXpow2) FFT(direction,m,real,imag);
  1117. else DFT(direction,w,real,imag,real2,imag2);
  1119. for (k=0;k<w;k++) {
  1120. grid[k][j].x = real[k];
  1121. grid[k][j].y = imag[k];
  1122. }
  1123. }
  1124. free(real);
  1125. free(imag);
  1127. /* Transform the columns */
  1128. real = (double *)malloc(h * sizeof(double));
  1129. imag = (double *)malloc(h * sizeof(double));
  1131. m=0;
  1132. while((1<<m)<h) m++;
  1134. for (k=0;k<w;k++) {
  1135. for (j=0;j<h;j++) {
  1136. real[j] = grid[k][j].x;
  1137. imag[j] = grid[k][j].y;
  1138. }
  1140. if (bYpow2) FFT(direction,m,real,imag);
  1141. else DFT(direction,h,real,imag,real2,imag2);
  1143. for (j=0;j<h;j++) {
  1144. grid[k][j].x = real[j];
  1145. grid[k][j].y = imag[j];
  1146. }
  1147. }
  1148. free(real);
  1149. free(imag);
  1151. free(real2);
  1152. free(imag2);
  1154. /* converting from double to byte, there is a HUGE loss in the dynamics
  1155.   "nn" tries to keep an acceptable SNR, but 8bit=48dB: don't ask more */
  1156. double nn=pow((double)2,(double)log((double)max(w,h))/(double)log((double)2)-4);
  1157. //reversed gain for reversed transform
  1158. if (direction==-1) nn=1/nn;
  1159. //bMagnitude : just to see it on the screen
  1160. if (bMagnitude) nn*=4;
  1162. for (j=0;j<h;j++) {
  1163. for (k=0;k<w;k++) {
  1164. if (bMagnitude){
  1165. tmpReal->SetPixelIndex(k,j,(BYTE)max(0,min(255,(nn*(3+log(_cabs(grid[k][j])))))));
  1166. if (grid[k][j].x==0){
  1167. tmpImag->SetPixelIndex(k,j,(BYTE)max(0,min(255,(128+(atan(grid[k][j].y/0.0000000001)*nn)))));
  1168. } else {
  1169. tmpImag->SetPixelIndex(k,j,(BYTE)max(0,min(255,(128+(atan(grid[k][j].y/grid[k][j].x)*nn)))));
  1170. }
  1171. } else {
  1172. tmpReal->SetPixelIndex(k,j,(BYTE)max(0,min(255,(128 + grid[k][j].x*nn))));
  1173. tmpImag->SetPixelIndex(k,j,(BYTE)max(0,min(255,(128 + grid[k][j].y*nn))));
  1174. }
  1175. }
  1176. }
  1178. for (k=0;k<w;k++) free (grid[k]);
  1179. free (grid);
  1181. if (srcReal==0 && dstReal==0) delete tmpReal;
  1182. if (srcImag==0 && dstImag==0) delete tmpImag;
  1184. return true;
  1185. }
  1186. ////////////////////////////////////////////////////////////////////////////////
  1187. #endif //__BORLANDC__
  1188. ////////////////////////////////////////////////////////////////////////////////
  1189. bool CxImage::IsPowerof2(long x)
  1190. {
  1191. long i=0;
  1192. while ((1<<i)<x) i++;
  1193. if (x==(1<<i)) return true;
  1194. return false;
  1195. }
  1196. ////////////////////////////////////////////////////////////////////////////////
  1197. /*
  1198.    This computes an in-place complex-to-complex FFT 
  1199.    x and y are the real and imaginary arrays of n=2^m points.
  1200.    o(n)=n*log2(n)
  1201.    dir =  1 gives forward transform
  1202.    dir = -1 gives reverse transform 
  1203.    Written by Paul Bourke, July 1998
  1204.    FFT algorithm by Cooley and Tukey, 1965 
  1205. */
  1206. bool CxImage::FFT(int dir,int m,double *x,double *y)
  1207. {
  1208. long nn,i,i1,j,k,i2,l,l1,l2;
  1209. double c1,c2,tx,ty,t1,t2,u1,u2,z;
  1211. /* Calculate the number of points */
  1212. nn = 1<<m;
  1214. /* Do the bit reversal */
  1215. i2 = nn >> 1;
  1216. j = 0;
  1217. for (i=0;i<nn-1;i++) {
  1218. if (i < j) {
  1219. tx = x[i];
  1220. ty = y[i];
  1221. x[i] = x[j];
  1222. y[i] = y[j];
  1223. x[j] = tx;
  1224. y[j] = ty;
  1225. }
  1226. k = i2;
  1227. while (k <= j) {
  1228. j -= k;
  1229. k >>= 1;
  1230. }
  1231. j += k;
  1232. }
  1234. /* Compute the FFT */
  1235. c1 = -1.0;
  1236. c2 = 0.0;
  1237. l2 = 1;
  1238. for (l=0;l<m;l++) {
  1239. l1 = l2;
  1240. l2 <<= 1;
  1241. u1 = 1.0;
  1242. u2 = 0.0;
  1243. for (j=0;j<l1;j++) {
  1244. for (i=j;i<nn;i+=l2) {
  1245. i1 = i + l1;
  1246. t1 = u1 * x[i1] - u2 * y[i1];
  1247. t2 = u1 * y[i1] + u2 * x[i1];
  1248. x[i1] = x[i] - t1;
  1249. y[i1] = y[i] - t2;
  1250. x[i] += t1;
  1251. y[i] += t2;
  1252. }
  1253. z =  u1 * c1 - u2 * c2;
  1254. u2 = u1 * c2 + u2 * c1;
  1255. u1 = z;
  1256. }
  1257. c2 = sqrt((1.0 - c1) / 2.0);
  1258. if (dir == 1)
  1259. c2 = -c2;
  1260. c1 = sqrt((1.0 + c1) / 2.0);
  1261. }
  1263. /* Scaling for forward transform */
  1264. if (dir == 1) {
  1265. for (i=0;i<nn;i++) {
  1266. x[i] /= (double)nn;
  1267. y[i] /= (double)nn;
  1268. }
  1269. }
  1271.    return true;
  1272. }
  1273. ////////////////////////////////////////////////////////////////////////////////
  1274. /*
  1275.    Direct fourier transform o(n)=n^2
  1276.    Written by Paul Bourke, July 1998 
  1277. */
  1278. bool CxImage::DFT(int dir,long m,double *x1,double *y1,double *x2,double *y2)
  1279. {
  1280.    long i,k;
  1281.    double arg;
  1282.    double cosarg,sinarg;
  1283.    
  1284.    for (i=0;i<m;i++) {
  1285.       x2[i] = 0;
  1286.       y2[i] = 0;
  1287.       arg = - dir * 2.0 * 3.14159265358f * i / (double)m;
  1288.       for (k=0;k<m;k++) {
  1289.          cosarg = cos(k * arg);
  1290.          sinarg = sin(k * arg);
  1291.          x2[i] += (x1[k] * cosarg - y1[k] * sinarg);
  1292.          y2[i] += (x1[k] * sinarg + y1[k] * cosarg);
  1293.       }
  1294.    }
  1295.    
  1296.    /* Copy the data back */
  1297.    if (dir == 1) {
  1298.       for (i=0;i<m;i++) {
  1299.          x1[i] = x2[i] / m;
  1300.          y1[i] = y2[i] / m;
  1301.       }
  1302.    } else {
  1303.       for (i=0;i<m;i++) {
  1304.          x1[i] = x2[i];
  1305.          y1[i] = y2[i];
  1306.       }
  1307.    }
  1308.    
  1309.    return true;
  1310. }
  1311. ////////////////////////////////////////////////////////////////////////////////
  1312. bool CxImage::Combine(CxImage* r,CxImage* g,CxImage* b,CxImage* a, long colorspace)
  1313. {
  1314. if (r==0 || g==0 || b==0) return false;
  1316. long w = r->GetWidth();
  1317. long h = r->GetHeight();
  1319. Create(w,h,24);
  1321. g->Resample(w,h);
  1322. b->Resample(w,h);
  1324. if (a) {
  1325. a->Resample(w,h);
  1326. #if CXIMAGE_SUPPORT_ALPHA
  1327. AlphaCreate();
  1328. #endif //CXIMAGE_SUPPORT_ALPHA
  1329. }
  1331. RGBQUAD c;
  1332. for (long y=0;y<h;y++){
  1333. info.nProgress = (long)(100*y/h); //<Anatoly Ivasyuk>
  1334. for (long x=0;x<w;x++){
  1335. c.rgbRed=r->GetPixelIndex(x,y);
  1336. c.rgbGreen=g->GetPixelIndex(x,y);
  1337. c.rgbBlue=b->GetPixelIndex(x,y);
  1338. switch (colorspace){
  1339. case 1:
  1340. SetPixelColor(x,y,HSLtoRGB(c));
  1341. break;
  1342. case 2:
  1343. SetPixelColor(x,y,YUVtoRGB(c));
  1344. break;
  1345. case 3:
  1346. SetPixelColor(x,y,YIQtoRGB(c));
  1347. break;
  1348. case 4:
  1349. SetPixelColor(x,y,XYZtoRGB(c));
  1350. break;
  1351. default:
  1352. SetPixelColor(x,y,c);
  1353. }
  1354. #if CXIMAGE_SUPPORT_ALPHA
  1355. if (a) AlphaSet(x,y,a->GetPixelIndex(x,y));
  1356. #endif //CXIMAGE_SUPPORT_ALPHA
  1357. }
  1358. }
  1360. return true;
  1361. }
  1362. ////////////////////////////////////////////////////////////////////////////////
  1363. bool CxImage::Repair(float radius, long niterations, long colorspace)
  1364. {
  1365. if (!IsValid()) return false;
  1367. long w = GetWidth();
  1368. long h = GetHeight();
  1370. CxImage r,g,b;
  1372. r.Create(w,h,8);
  1373. g.Create(w,h,8);
  1374. b.Create(w,h,8);
  1376. switch (colorspace){
  1377. case 1:
  1378. SplitHSL(&r,&g,&b);
  1379. break;
  1380. case 2:
  1381. SplitYUV(&r,&g,&b);
  1382. break;
  1383. case 3:
  1384. SplitYIQ(&r,&g,&b);
  1385. break;
  1386. case 4:
  1387. SplitXYZ(&r,&g,&b);
  1388. break;
  1389. default:
  1390. SplitRGB(&r,&g,&b);
  1391. }
  1393. for (int i=0; i<niterations; i++){
  1394. RepairChannel(&r,radius);
  1395. RepairChannel(&g,radius);
  1396. RepairChannel(&b,radius);
  1397. }
  1399. CxImage* a=NULL;
  1400. #if CXIMAGE_SUPPORT_ALPHA
  1401. if (AlphaIsValid()){
  1402. a = new CxImage();
  1403. AlphaSplit(a);
  1404. }
  1405. #endif
  1407. Combine(&r,&g,&b,a,colorspace);
  1409. delete a;
  1411. return true;
  1412. }
  1413. ////////////////////////////////////////////////////////////////////////////////
  1414. bool CxImage::RepairChannel(CxImage *ch, float radius)
  1415. {
  1416. if (ch==NULL) return false;
  1417. CxImage tmp(*ch);
  1418. long w = ch->GetWidth()-1;
  1419. long h = ch->GetHeight()-1;
  1421. double correction,ix,iy,ixx,ixy,iyy,den,num;
  1422. int x,y,xy0,xp1,xm1,yp1,ym1;
  1423. for(x=1; x<w; x++){
  1424. for(y=1; y<h; y++){
  1426. xy0 = ch->GetPixelIndex(x,y);
  1427. xm1 = ch->GetPixelIndex(x-1,y);
  1428. xp1 = ch->GetPixelIndex(x+1,y);
  1429. ym1 = ch->GetPixelIndex(x,y-1);
  1430. yp1 = ch->GetPixelIndex(x,y+1);
  1432. ix= (xp1-xm1)/2.0;
  1433. iy= (yp1-ym1)/2.0;
  1434. ixx= xp1 - 2.0 * xy0 + xm1;
  1435. iyy= yp1 - 2.0 * xy0 + ym1;
  1436. ixy=(ch->GetPixelIndex(x+1,y+1)+ch->GetPixelIndex(x-1,y-1)-
  1437.  ch->GetPixelIndex(x-1,y+1)-ch->GetPixelIndex(x+1,y-1))/4.0;
  1439. num= (1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy;
  1440. den= 1.0+ix*ix+iy*iy;
  1441. correction = num/den;
  1443. tmp.SetPixelIndex(x,y,(BYTE)min(255,max(0,(xy0 + radius * correction))));
  1444. }
  1445. }
  1447. for (x=0;x<=w;x++){
  1448. tmp.SetPixelIndex(x,0,ch->GetPixelIndex(x,0));
  1449. tmp.SetPixelIndex(x,h,ch->GetPixelIndex(x,h));
  1450. }
  1451. for (y=0;y<=h;y++){
  1452. tmp.SetPixelIndex(0,y,ch->GetPixelIndex(0,y));
  1453. tmp.SetPixelIndex(w,y,ch->GetPixelIndex(w,y));
  1454. }
  1455. ch->Transfer(tmp);
  1456. return true;
  1457. }
  1458. ////////////////////////////////////////////////////////////////////////////////
  1459. bool CxImage::Contour()
  1460. {
  1461. if (!pDib) return false;
  1463. long Ksize = 3;
  1464. long k2 = Ksize/2;
  1465. long kmax= Ksize-k2;
  1466. long i,j,k;
  1467. BYTE maxr,maxg,maxb;
  1468. RGBQUAD pix1,pix2;
  1470. CxImage tmp(*this,pSelection!=0,true,true);
  1472. long xmin,xmax,ymin,ymax;
  1473. if (pSelection){
  1474. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  1475. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  1476. } else {
  1477. xmin = ymin = 0;
  1478. xmax = head.biWidth; ymax=head.biHeight;
  1479. }
  1481. for(long y=ymin; y<ymax; y++){
  1482. info.nProgress = (long)(100*y/head.biHeight);
  1483. if (info.nEscape) break;
  1484. for(long x=xmin; x<xmax; x++){
  1485. #if CXIMAGE_SUPPORT_SELECTION
  1486. if (SelectionIsInside(x,y))
  1487. #endif //CXIMAGE_SUPPORT_SELECTION
  1488. {
  1489. pix1 = GetPixelColor(x,y);
  1490. maxr=maxg=maxb=0;
  1491. for(j=-k2, i=0;j<kmax;j++){
  1492. for(k=-k2;k<kmax;k++, i++){
  1493. pix2=GetPixelColor(x+j,y+k);
  1494. if ((pix2.rgbBlue-pix1.rgbBlue)>maxb) maxb = pix2.rgbBlue;
  1495. if ((pix2.rgbGreen-pix1.rgbGreen)>maxg) maxg = pix2.rgbGreen;
  1496. if ((pix2.rgbRed-pix1.rgbRed)>maxr) maxr = pix2.rgbRed;
  1497. }
  1498. }
  1499. pix1.rgbBlue=(BYTE)(255-maxb);
  1500. pix1.rgbGreen=(BYTE)(255-maxg);
  1501. pix1.rgbRed=(BYTE)(255-maxr);
  1502. tmp.SetPixelColor(x,y,pix1);
  1503. }
  1504. }
  1505. }
  1506. Transfer(tmp);
  1507. return true;
  1508. }
  1509. ////////////////////////////////////////////////////////////////////////////////
  1510. bool CxImage::Jitter(long radius)
  1511. {
  1512. if (!pDib) return false;
  1514. long nx,ny;
  1516. CxImage tmp(*this,pSelection!=0,true,true);
  1518. long xmin,xmax,ymin,ymax;
  1519. if (pSelection){
  1520. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  1521. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  1522. } else {
  1523. xmin = ymin = 0;
  1524. xmax = head.biWidth; ymax=head.biHeight;
  1525. }
  1527. for(long y=ymin; y<ymax; y++){
  1528. info.nProgress = (long)(100*y/head.biHeight);
  1529. if (info.nEscape) break;
  1530. for(long x=xmin; x<xmax; x++){
  1531. #if CXIMAGE_SUPPORT_SELECTION
  1532. if (SelectionIsInside(x,y))
  1533. #endif //CXIMAGE_SUPPORT_SELECTION
  1534. {
  1535. nx=x+(long)((rand()/(float)RAND_MAX - 0.5)*(radius*2));
  1536. ny=y+(long)((rand()/(float)RAND_MAX - 0.5)*(radius*2));
  1537. if (!IsInside(nx,ny)) {
  1538. nx=x;
  1539. ny=y;
  1540. }
  1541. if (head.biClrUsed==0){
  1542. tmp.SetPixelColor(x,y,GetPixelColor(nx,ny));
  1543. } else {
  1544. tmp.SetPixelIndex(x,y,GetPixelIndex(nx,ny));
  1545. }
  1546. #if CXIMAGE_SUPPORT_ALPHA
  1547. tmp.AlphaSet(x,y,AlphaGet(nx,ny));
  1548. #endif //CXIMAGE_SUPPORT_ALPHA
  1549. }
  1550. }
  1551. }
  1552. Transfer(tmp);
  1553. return true;
  1554. }
  1555. ////////////////////////////////////////////////////////////////////////////////
  1556. /* <nipper> generates a 1-D convolution matrix to be used for each pass of 
  1557. * a two-pass gaussian blur.  Returns the length of the matrix.
  1558. */
  1559. int CxImage::gen_convolve_matrix (float radius, float **cmatrix_p)
  1560. {
  1561. int matrix_length;
  1562. int matrix_midpoint;
  1563. float* cmatrix;
  1564. int i,j;
  1565. float std_dev;
  1566. float sum;
  1568. /* we want to generate a matrix that goes out a certain radius
  1569. * from the center, so we have to go out ceil(rad-0.5) pixels,
  1570. * inlcuding the center pixel.  Of course, that's only in one direction,
  1571. * so we have to go the same amount in the other direction, but not count
  1572. * the center pixel again.  So we double the previous result and subtract
  1573. * one.
  1574. * The radius parameter that is passed to this function is used as
  1575. * the standard deviation, and the radius of effect is the
  1576. * standard deviation * 2.  It's a little confusing.
  1577. */
  1578. radius = (float)fabs(radius) + 1.0f;
  1580. std_dev = radius;
  1581. radius = std_dev * 2;
  1583. /* go out 'radius' in each direction */
  1584. matrix_length = int (2 * ceil(radius-0.5) + 1);
  1585. if (matrix_length <= 0) matrix_length = 1;
  1586. matrix_midpoint = matrix_length/2 + 1;
  1587. *cmatrix_p = new float[matrix_length];
  1588. cmatrix = *cmatrix_p;
  1590. /*  Now we fill the matrix by doing a numeric integration approximation
  1591. * from -2*std_dev to 2*std_dev, sampling 50 points per pixel.
  1592. * We do the bottom half, mirror it to the top half, then compute the
  1593. * center point.  Otherwise asymmetric quantization errors will occur.
  1594. *  The formula to integrate is e^-(x^2/2s^2).
  1595. */
  1597. /* first we do the top (right) half of matrix */
  1598. for (i = matrix_length/2 + 1; i < matrix_length; i++)
  1599.     {
  1600. float base_x = i - (float)floor((float)(matrix_length/2)) - 0.5f;
  1601. sum = 0;
  1602. for (j = 1; j <= 50; j++)
  1603. {
  1604. if ( base_x+0.02*j <= radius ) 
  1605. sum += (float)exp (-(base_x+0.02*j)*(base_x+0.02*j) / 
  1606. (2*std_dev*std_dev));
  1607. }
  1608. cmatrix[i] = sum/50;
  1609.     }
  1611. /* mirror the thing to the bottom half */
  1612. for (i=0; i<=matrix_length/2; i++) {
  1613. cmatrix[i] = cmatrix[matrix_length-1-i];
  1614. }
  1616. /* find center val -- calculate an odd number of quanta to make it symmetric,
  1617. * even if the center point is weighted slightly higher than others. */
  1618. sum = 0;
  1619. for (j=0; j<=50; j++)
  1620.     {
  1621. sum += (float)exp (-(0.5+0.02*j)*(0.5+0.02*j) /
  1622. (2*std_dev*std_dev));
  1623.     }
  1624. cmatrix[matrix_length/2] = sum/51;
  1626. /* normalize the distribution by scaling the total sum to one */
  1627. sum=0;
  1628. for (i=0; i<matrix_length; i++) sum += cmatrix[i];
  1629. for (i=0; i<matrix_length; i++) cmatrix[i] = cmatrix[i] / sum;
  1631. return matrix_length;
  1632. }
  1633. ////////////////////////////////////////////////////////////////////////////////
  1634. /* ----------------------- gen_lookup_table ----------------------- */
  1635. /* <nipper> generates a lookup table for every possible product of 0-255 and
  1636. each value in the convolution matrix.  The returned array is
  1637. indexed first by matrix position, then by input multiplicand (?)
  1638. value.
  1639. */
  1640. float* CxImage::gen_lookup_table (float *cmatrix, int cmatrix_length)
  1641. {
  1642. float* lookup_table = new float[cmatrix_length * 256];
  1643. float* lookup_table_p = lookup_table;
  1644. float* cmatrix_p      = cmatrix;
  1646. for (int i=0; i<cmatrix_length; i++)
  1647.     {
  1648. for (int j=0; j<256; j++)
  1649. {
  1650. *(lookup_table_p++) = *cmatrix_p * (float)j;
  1651. }
  1652. cmatrix_p++;
  1653.     }
  1655. return lookup_table;
  1656. }
  1657. ////////////////////////////////////////////////////////////////////////////////
  1658. /* <nipper> this function is written as if it is blurring a column at a time,
  1659. even though it can operate on rows, too.  There is no difference
  1660. in the processing of the lines, at least to the blur_line function. */
  1661. void CxImage::blur_line (float *ctable, float *cmatrix, int cmatrix_length, BYTE* cur_col, BYTE* dest_col, int y, long bytes)
  1662. {
  1663. float scale;
  1664. float sum;
  1665. int i=0, j=0;
  1666. int row;
  1667. int cmatrix_middle = cmatrix_length/2;
  1669. float *cmatrix_p;
  1670. BYTE  *cur_col_p;
  1671. BYTE  *cur_col_p1;
  1672. BYTE  *dest_col_p;
  1673. float *ctable_p;
  1675. /* this first block is the same as the non-optimized version --
  1676. * it is only used for very small pictures, so speed isn't a
  1677. * big concern.
  1678. */
  1679. if (cmatrix_length > y)
  1680.     {
  1681. for (row = 0; row < y ; row++)
  1682. {
  1683. scale=0;
  1684. /* find the scale factor */
  1685. for (j = 0; j < y ; j++)
  1686. {
  1687. /* if the index is in bounds, add it to the scale counter */
  1688. if ((j + cmatrix_length/2 - row >= 0) &&
  1689. (j + cmatrix_length/2 - row < cmatrix_length))
  1690. scale += cmatrix[j + cmatrix_length/2 - row];
  1691. }
  1692. for (i = 0; i<bytes; i++)
  1693. {
  1694. sum = 0;
  1695. for (j = 0; j < y; j++)
  1696. {
  1697. if ((j >= row - cmatrix_length/2) &&
  1698. (j <= row + cmatrix_length/2))
  1699. sum += cur_col[j*bytes + i] * cmatrix[j];
  1700. }
  1701. dest_col[row*bytes + i] = (BYTE)(0.5f + sum / scale);
  1702. }
  1703. }
  1704.     }
  1705. else
  1706.     {
  1707. /* for the edge condition, we only use available info and scale to one */
  1708. for (row = 0; row < cmatrix_middle; row++)
  1709. {
  1710. /* find scale factor */
  1711. scale=0;
  1712. for (j = cmatrix_middle - row; j<cmatrix_length; j++)
  1713. scale += cmatrix[j];
  1714. for (i = 0; i<bytes; i++)
  1715. {
  1716. sum = 0;
  1717. for (j = cmatrix_middle - row; j<cmatrix_length; j++)
  1718. {
  1719. sum += cur_col[(row + j-cmatrix_middle)*bytes + i] * cmatrix[j];
  1720. }
  1721. dest_col[row*bytes + i] = (BYTE)(0.5f + sum / scale);
  1722. }
  1723. }
  1724. /* go through each pixel in each col */
  1725. dest_col_p = dest_col + row*bytes;
  1726. for (; row < y-cmatrix_middle; row++)
  1727. {
  1728. cur_col_p = (row - cmatrix_middle) * bytes + cur_col;
  1729. for (i = 0; i<bytes; i++)
  1730. {
  1731. sum = 0;
  1732. cmatrix_p = cmatrix;
  1733. cur_col_p1 = cur_col_p;
  1734. ctable_p = ctable;
  1735. for (j = cmatrix_length; j>0; j--)
  1736. {
  1737. sum += *(ctable_p + *cur_col_p1);
  1738. cur_col_p1 += bytes;
  1739. ctable_p += 256;
  1740. }
  1741. cur_col_p++;
  1742. *(dest_col_p++) = (BYTE)(0.5f + sum);
  1743. }
  1744. }
  1746. /* for the edge condition , we only use available info, and scale to one */
  1747. for (; row < y; row++)
  1748. {
  1749. /* find scale factor */
  1750. scale=0;
  1751. for (j = 0; j< y-row + cmatrix_middle; j++)
  1752. scale += cmatrix[j];
  1753. for (i = 0; i<bytes; i++)
  1754. {
  1755. sum = 0;
  1756. for (j = 0; j<y-row + cmatrix_middle; j++)
  1757. {
  1758. sum += cur_col[(row + j-cmatrix_middle)*bytes + i] * cmatrix[j];
  1759. }
  1760. dest_col[row*bytes + i] = (BYTE) (0.5f + sum / scale);
  1761. }
  1762. }
  1763.     }
  1764. }
  1765. ////////////////////////////////////////////////////////////////////////////////
  1766. /* <nipper> */
  1767. bool CxImage::UnsharpMask(float radius /*= 5.0*/, float amount /*= 0.5*/, int threshold /*= 0*/)
  1768. {
  1769. if (!pDib) return false;
  1771. if (!(head.biBitCount == 24 || IsGrayScale()))
  1772. return false;
  1774. CxImage tmp(*this);
  1776. CImageIterator itSrc(this);
  1777. CImageIterator itDst(&tmp);
  1779. // generate convolution matrix and make sure it's smaller than each dimension
  1780. float *cmatrix = NULL;
  1781. int cmatrix_length = gen_convolve_matrix(radius, &cmatrix);
  1782. // generate lookup table
  1783. float *ctable = gen_lookup_table(cmatrix, cmatrix_length);
  1785. double dbScaler = 33.3/head.biHeight;
  1787. // blur the rows
  1788.     for (int y=0;y<head.biHeight;y++)
  1789. {
  1790. if (info.nEscape) break;
  1791. info.nProgress = (long)(y*dbScaler);
  1793. blur_line(ctable, cmatrix, cmatrix_length, itSrc.GetRow(y), itDst.GetRow(y), head.biWidth, 3);
  1794. }
  1796. // blur the cols
  1797.     BYTE* cur_col = new BYTE[head.biHeight*3];
  1798.     BYTE* dest_col = new BYTE[head.biHeight*3];
  1800. dbScaler = 33.3/head.biWidth;
  1802. int x;
  1804. for (x=0;x<head.biWidth;x++)
  1805. {
  1806. if (info.nEscape) break;
  1807. info.nProgress = (long)(33.3+x*dbScaler);
  1809. itSrc.GetCol(cur_col, x);
  1810. itDst.GetCol(dest_col, x);
  1811. blur_line(ctable, cmatrix, cmatrix_length, cur_col, dest_col, head.biHeight, 3);
  1812. itSrc.SetCol(cur_col, x);
  1813. itDst.SetCol(dest_col, x);
  1814. }
  1816. delete [] cur_col;
  1817. delete [] dest_col;
  1819. delete [] cmatrix;
  1820. delete [] ctable;
  1822. // these are used for the merging step 
  1823. int diff;
  1824. int value;
  1826. dbScaler = 33.3/head.biHeight;
  1828. // merge the source and destination (which currently contains
  1829. // the blurred version) images
  1830.     for (LONG y=0;y<head.biHeight;y++)
  1831. {
  1832. if (info.nEscape) break;
  1833. info.nProgress = (long)(66.6+y*dbScaler);
  1835. value = 0;
  1836. // get source row
  1837. BYTE* cur_row = itSrc.GetRow(y);
  1838. // get dest row
  1839. BYTE* dest_row = itDst.GetRow(y);
  1840. // combine the two
  1841. for (int u = 0; u < x; u++)
  1842. {
  1843. for (int v = 0; v < 3; v++)
  1844. {
  1845. diff = (cur_row[u*3+v] - dest_row[u*3+v]);
  1846. // do tresholding
  1847. if (abs (2 * diff) < threshold)
  1848. diff = 0;
  1850. value = int(cur_row[u*3+v] + amount * diff);
  1852. if (value < 0) dest_row[u*3+v] =0;
  1853. else if (value > 255) dest_row[u*3+v] = 255;
  1854. else  dest_row[u*3+v] = value;
  1855. }
  1856. }
  1857. }
  1859. Transfer(tmp);
  1861. return TRUE;
  1862. }
  1863. ////////////////////////////////////////////////////////////////////////////////
  1864. bool CxImage::Lut(BYTE* pLut)
  1865. {
  1866. if (!pDib || !pLut) return false;
  1867. RGBQUAD color;
  1869. double dbScaler;
  1870. if (head.biClrUsed==0){
  1872. long xmin,xmax,ymin,ymax;
  1873. if (pSelection){
  1874. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  1875. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  1876. } else {
  1877. // faster loop for full image
  1878. BYTE *iSrc=info.pImage;
  1879. for(unsigned long i=0; i < head.biSizeImage ; i++){
  1880. *iSrc++ = pLut[*iSrc];
  1881. }
  1882. return true;
  1883. }
  1885. dbScaler = 100.0/ymax;
  1887. for(long y=ymin; y<ymax; y++){
  1888. info.nProgress = (long)(y*dbScaler); //<Anatoly Ivasyuk>
  1889. for(long x=xmin; x<xmax; x++){
  1890. #if CXIMAGE_SUPPORT_SELECTION
  1891. if (SelectionIsInside(x,y))
  1892. #endif //CXIMAGE_SUPPORT_SELECTION
  1893. {
  1894. color = GetPixelColor(x,y);
  1895. color.rgbRed = pLut[color.rgbRed];
  1896. color.rgbGreen = pLut[color.rgbGreen];
  1897. color.rgbBlue = pLut[color.rgbBlue];
  1898. SetPixelColor(x,y,color);
  1899. }
  1900. }
  1901. }
  1902. #if CXIMAGE_SUPPORT_SELECTION
  1903. } else if (pSelection && (head.biBitCount==8) && IsGrayScale()){
  1904. long xmin,xmax,ymin,ymax;
  1905. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  1906. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  1908. dbScaler = 100.0/ymax;
  1909. for(long y=ymin; y<ymax; y++){
  1910. info.nProgress = (long)(y*dbScaler);
  1911. for(long x=xmin; x<xmax; x++){
  1912. if (SelectionIsInside(x,y))
  1913. {
  1914. SetPixelIndex(x,y,pLut[GetPixelIndex(x,y)]);
  1915. }
  1916. }
  1917. }
  1918. #endif //CXIMAGE_SUPPORT_SELECTION
  1919. } else {
  1920. for(DWORD j=0; j<head.biClrUsed; j++){
  1921. color = GetPaletteColor((BYTE)j);
  1922. color.rgbRed = pLut[color.rgbRed];
  1923. color.rgbGreen = pLut[color.rgbGreen];
  1924. color.rgbBlue = pLut[color.rgbBlue];
  1925. SetPaletteColor((BYTE)j,color);
  1926. }
  1927. }
  1928. return true;
  1930. }
  1931. ////////////////////////////////////////////////////////////////////////////////
  1932. bool CxImage::Lut(BYTE* pLutR, BYTE* pLutG, BYTE* pLutB, BYTE* pLutA)
  1933. {
  1934. if (!pDib || !pLutR || !pLutG || !pLutB) return false;
  1935. RGBQUAD color;
  1937. double dbScaler;
  1938. if (head.biClrUsed==0){
  1940. long xmin,xmax,ymin,ymax;
  1941. if (pSelection){
  1942. xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
  1943. ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
  1944. } else {
  1945. xmin = ymin = 0;
  1946. xmax = head.biWidth; ymax=head.biHeight;
  1947. }
  1949. dbScaler = 100.0/ymax;
  1951. for(long y=ymin; y<ymax; y++){
  1952. info.nProgress = (long)(y*dbScaler);
  1953. for(long x=xmin; x<xmax; x++){
  1954. #if CXIMAGE_SUPPORT_SELECTION
  1955. if (SelectionIsInside(x,y))
  1956. #endif //CXIMAGE_SUPPORT_SELECTION
  1957. {
  1958. color = GetPixelColor(x,y);
  1959. color.rgbRed =   pLutR[color.rgbRed];
  1960. color.rgbGreen = pLutG[color.rgbGreen];
  1961. color.rgbBlue =  pLutB[color.rgbBlue];
  1962. if (pLutA) color.rgbReserved=pLutA[color.rgbReserved];
  1963. SetPixelColor(x,y,color,true);
  1964. }
  1965. }
  1966. }
  1967. } else {
  1968. for(DWORD j=0; j<head.biClrUsed; j++){
  1969. color = GetPaletteColor((BYTE)j);
  1970. color.rgbRed =   pLutR[color.rgbRed];
  1971. color.rgbGreen = pLutG[color.rgbGreen];
  1972. color.rgbBlue =  pLutB[color.rgbBlue];
  1973. SetPaletteColor((BYTE)j,color);
  1974. }
  1975. }
  1977. return true;
  1979. }
  1980. ////////////////////////////////////////////////////////////////////////////////
  1981. /*bool CxImage::FloodFill(int x, int y, RGBQUAD FillColor)
  1982. {
  1983. //<JDL>
  1984. if (!pDib) return false;
  1985.     FloodFill2(x,y,GetPixelColor(x,y),FillColor);
  1986. return true;
  1987. }
  1988. ////////////////////////////////////////////////////////////////////////////////
  1989. void CxImage::FloodFill2(int x, int y, RGBQUAD old_color, RGBQUAD new_color)
  1990. {
  1991. // Fill in the actual pixels. 
  1992. // Function steps recursively until it finds borders (color that is not old_color)
  1993. if (!IsInside(x,y)) return;
  1995. RGBQUAD r = GetPixelColor(x,y);
  1996. COLORREF cr = RGB(r.rgbRed,r.rgbGreen,r.rgbBlue);
  1998. if(cr == RGB(old_color.rgbRed,old_color.rgbGreen,old_color.rgbBlue)
  1999. && cr != RGB(new_color.rgbRed,new_color.rgbGreen,new_color.rgbBlue) ) {
  2001. // the above if statement, after && is there to prevent
  2002. // stack overflows.  The program will continue to find 
  2003. // colors if you flood-fill an entire region (entire picture)
  2005. SetPixelColor(x,y,new_color);
  2007. FloodFill2((x+1),y,old_color,new_color);
  2008. FloodFill2((x-1),y,old_color,new_color);
  2009. FloodFill2(x,(y+1),old_color,new_color);
  2010. FloodFill2(x,(y-1),old_color,new_color);
  2011. }
  2012. }*/
  2013. ///////////////////////////////////////////////////////////////////////////////
  2014. #endif //CXIMAGE_SUPPORT_DSP