Назад к лучшим решениям Status: AC, problem ZDIP, contest ZEL07. By ding0 (NETALL), 2007-03-15 21:20:41.
  1. #pragma warning(disable : 4996)
  2.  
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <math.h>
  6.  
  7. #define maxSize 200
  8. #define byte unsigned char
  9.  
  10. int GetColorForResult(int row, int col);
  11. int GetColorForDiffValue(int row, int col);
  12.  
  13. bool badPoints[maxSize][maxSize];
  14.  
  15. void ClearBadPoints()
  16. {
  17. 	for (int i=0; i<maxSize; i++)
  18. 		for (int j=0; j<maxSize; j++)
  19. 		{
  20. 			badPoints[i][j] = false;
  21. 		}
  22. }
  23.  
  24. byte sourceImage[maxSize][maxSize];
  25. byte resultImage[maxSize][maxSize];
  26.  
  27. int q, h, w;
  28.  
  29. void ReadImage()
  30. {
  31. 	for (int i=0; i<h; i++)
  32. 	{
  33. 		for (int j=0; j<w; j++)
  34. 		{
  35. 			scanf("%d", &sourceImage[i][j]);
  36. 		}
  37. 	}
  38. }
  39.  
  40. void WriteImage()
  41. {
  42. 	printf("%d %d\n", h, w);
  43.  
  44. 	for (int i=0; i<h; i++)
  45. 	{
  46. 		if (i > 0) printf("\n");
  47.  
  48. 		for (int j=0; j<w; j++)
  49. 		{
  50. 			if (j > 0) printf(" ");
  51.  
  52. 			printf("%d", resultImage[i][j]);			
  53. 		}
  54. 	}
  55. }
  56.  
  57.  
  58. long diffcount;
  59.  
  60. struct Diff
  61. {
  62. 	int i, j, value;
  63. };
  64.  
  65. Diff diffs[maxSize*maxSize];
  66.  
  67. void CopySourceToResult()
  68. {
  69. 	for (int i=0; i<h; i++)
  70. 	{
  71. 		for (int j=0; j<w; j++)
  72. 		{
  73. 			resultImage[i][j] = sourceImage[i][j];
  74. 		}
  75. 	}
  76. }
  77.  
  78. void CopyResultToSource()
  79. {
  80. 	for (int i=0; i<h; i++)
  81. 	{
  82. 		for (int j=0; j<w; j++)
  83. 		{
  84. 			sourceImage[i][j] = resultImage[i][j];
  85. 		}
  86. 	}
  87. }
  88.  
  89.  
  90. void QuickSort(long k1, long k2)
  91. {
  92. 	long in1, in2;
  93. 	int Temp;
  94. 	Diff v;
  95.  
  96. 	if ((k2-k1)
 > 1)
  97. 	{
  98. 		in1 = k1;
  99. 		in2 = k2;
  100. 		Temp = diffs[(k1+k2) / 2].value;
  101.  
  102. 		do
  103. 		{
  104. 			while (diffs[in1].value > Temp) in1++;
  105. 			while (diffs[in2].value < Temp) in2--;
  106.  
  107. 			if (in1 <= in2)
  108. 			{
  109. 				v = diffs[in1];
  110. 				diffs[in1] = diffs[in2];
  111. 				diffs[in2] = v;
  112. 				in1++;
  113. 				in2--;
  114. 			}
  115. 		} while (in1 <= in2);
  116.  
  117. 		if (k1 < in2) QuickSort(k1, in2);
  118. 		if (in1 < k2) QuickSort(in1, k2);
  119. 	}
  120. 	else
  121. 	{
  122. 		if (diffs[k1].value < diffs[k2].value)
  123. 		{
  124. 			v = diffs[k1];
  125. 			diffs[k1] = diffs[k2];
  126. 			diffs[k2] = v;
  127. 		}
  128. 	}
  129. }
  130.  
  131. void SortDiffs()
  132. {
  133. 	QuickSort(0, diffcount-1);
  134. }
  135.  
  136.  
  137. void ApplyDiffs()
  138. {
  139. 	long actualCount = h * w * q / 100;
  140.  
  141. 	if ((diffcount > 0) && (actualCount > 0))
  142. 	{
  143. 		for (int i=0; i<diffcount; i++)

  144. 		{
  145. 			diffs[i].value = abs(GetColorForDiffValue(diffs[i].i, diffs[i].j) - sourceImage[diffs[i].i][diffs[i].j]);
  146. 		}
  147.  
  148. 		SortDiffs();
  149.  
  150. 		if (diffcount < actualCount)
  151. 		{
  152. 			actualCount = diffcount;
  153. 		}
  154.  
  155. 		for (int i=0; i<actualCount; i++)
  156. 		{
  157. 			resultImage[diffs[i].i][diffs[i].j] = GetColorForResult(diffs[i].i, diffs[i].j);
  158. 		}
  159. 	}	
  160. }
  161.  
  162. int GetCountBigger(int row, int col, int thres)
  163. {
  164. 	int res = 0;
  165.  
  166. 	for (int i=-1; i<=+1; i++)	
  167. 		for (int j=-1; j<=+1; j++)
  168. 			if ((i != 0) || (j != 0))
  169. 			{
  170. 				if (((i + row) >= 0) && ((i + row) < h) && ((j + col) >= 0) && ((j + col) < w))
  171. 				{
  172. 					if (((int)sourceImage[i+row][j+col] - (int)sourceImage[row][col]) >= thres)
  173. 					{
  174. 						res++;
  175. 					}
  176. 				}
  177. 			}
  178.  
  179. 	return res;
  180. }
  181.  
  182. int GetCountSmaller(int row, int col, int thres)
  183. {
  184. 	int res = 0;
  185.  
  186. 	for (int i=-1; i<=+1; i++)	
  187. 		for (int j=-1; j<=+1; j++)
  188. 			if ((i != 0) || (j != 0))
  189. 			{
  190. 				if (((i + row) >= 0) && ((i + row) < h) && ((j + col) >= 0) && ((j + col) < w))
  191. 				{
  192. 					if (((int)sourceImage[row][col] - (int)sourceImage[i+row][j+col]) >= thres)
  193. 					{
  194. 						res++;
  195. 					}
  196. 				}
  197. 			}
  198.  
  199. 	return res;
  200. }
  201.  
  202. int MeanAroundColor(int row, int col, bool useBadPoints)
  203. {
  204. 	int pointscount = 0;
  205. 	int res = 0;
  206.  
  207. 	for (int i=-1; i<=+1; i++)	
  208. 		for (int j=-1; j<=+1; j++)
  209. 			if ((i != 0) || (j != 
0))
  210. 				if (((i + row) >= 0) && ((i + row) < h) && ((j + col) >= 0) && ((j + col) < w))
  211. 				{
  212. 					if ((useBadPoints) || (!badPoints[i+row][j+col]))
  213. 					{
  214. 						res = res + sourceImage[i+row][j+col];
  215. 						pointscount++;
  216.  
  217. 						if ((i == 0) || (j == 0))
  218. 						{
  219. 							res = res + sourceImage[i+row][j+col];
  220. 							pointscount++;
  221. 						}
  222. 					}
  223. 				}
  224.  
  225. 	if (pointscount > 0)
  226. 	{
  227. 		res = res / pointscount;
  228. 	}
  229.  
  230. 	return res;
  231. }
  232.  
  233. int MedianColor(int row, int col, bool useBadPoints)
  234. {
  235. 	int pointscount = 0;
  236. 	int points[20];
  237.  
  238. 	for (int i=-1; i<=+1; i++)	
  239. 		for (int j=-1; j<=+1; j++)
  240. 			//if ((i != 0) || (j != 0))
  241. 				if (((i + row) >= 0) && ((i + row) < h) && ((j + col) >= 0) && ((j + col) < w))
  242. 				{
  243. 					if ((useBadPoints) || (!badPoints[i+row][j+col]))
  244. 					{
  245. 						pointscount++;
  246. 						points[
pointscount] = sourceImage[i+row][j+col];
  247.  
  248. 						if (i*j == 0)
  249. 						{
  250. 							pointscount++;
  251. 							points[pointscount] = sourceImage[i+row][j+col];
  252.  
  253. 							if (i+j == 0)
  254. 							{
  255. 								pointscount++;
  256. 								points[pointscount] = sourceImage[i+row][j+col];
  257. 								pointscount++;
  258. 								points[pointscount] = sourceImage[i+row][j+col];
  259. 							}
  260. 						}
  261. 					}
  262. 				}
  263.  
  264. 	if (pointscount > 0)
  265. 	{
  266. 		for (int i=pointscount-1; i>=0; i--)
  267. 			for (int j=1; j<=i; j++)
  268. 				if (points[j] > points[j+1])
  269. 				{
  270. 					int temp = points[j];
  271. 					points[j] = points[j+1];
  272. 					points[j+1] = temp;
  273. 				}
  274. 	}
  275.  
  276. 	if ((pointscount % 2) != 0)
  277. 	{
  278. 		pointscount = (pointscount / 2) + 1;
  279. 	}
  280. 	else
  281. 	{
  282. 		pointscount = pointscount / 2;
  283. 	}
  284.  
  285. 	return points[pointscount];
  286. }
  287.  
  288. int GetAroundPointsCount(int row, int col)
  289. {
  290. 	int pointscount = 0;
  291. 	
  292. 	for (int i=-1; i<=+1; i++)	
  293. 		for (int j=-1; j<=+1; j++)
  294. 			if ((i != 0) || (j != 0))
  295. 				if (((i + row) >= 0) && ((i + row) < h) && ((j + col) >= 0) && ((j + col) < w))
  296. 				{
  297. 					pointscount++;
  298. 				}
  299.  
  300. 	return pointscount;
  301. }
  302.  
  303.  
  304. void FilterSinglePoints(int thres)
  305. {
  306. 	for (int i=0; i<h; i++)
  307. 		for (int j=0; j<w; j++)
  308. 		{	
  309. 			int pointsCount = GetAroundPointsCount(i, j);
  310.  
  311. 			int countB = GetCountBigger(i, j, thres);
  312. 			int countS = GetCountSmaller(i, j, thres);
  313.  
  314. 			if ((countB == pointsCount) || (countS == pointsCount))
  315. 			{
  316. 				diffcount++;
  317. 				diffs[diffcount].i = i;
  318. 				diffs[diffcount].j = j;
  319. 				
  320. 				badPoints[i][j] = true;
  321. 			}
  322. 		}
  323. }
  324.  
  325. int GetColorForDiffValue(int row, int col)
  326. {
  327. 	return MeanAroundColor(row, col, false);
  328. }
  329.  
  330. int GetColorForResult(
int row, int col)
  331. {
  332. 	return MedianColor(row, col, false);
  333. }
  334.  
  335. void FillLines(bool testBlocked)
  336. {
  337. 	for (int i=0; i<h; i++)
  338. 		for (int j=0; j<w; j++)
  339. 		{
  340. 			// hor ->>>
  341. 			if (j + 4 < w)			
  342. 			{
  343. 				if ((resultImage[i][j] == resultImage[i][j+1]) &&				   
  344. 					(resultImage[i][j] != resultImage[i][j+2]) &&
  345. 					(resultImage[i][j] == resultImage[i][j+3]) &&
  346. 					(resultImage[i][j] == resultImage[i][j+4]))
  347. 				{
  348. 					bool blocked = false;
  349.  
  350. 					if (testBlocked)
  351. 					{
  352. 						if ((i + 1 < h) && 
  353. 							(resultImage[i+1][j+2] == resultImage[i][j+2]))
  354. 						{
  355. 							blocked = true;
  356. 						}
  357.  
  358. 						if ((i - 1 > 0) && 
  359. 							(resultImage[i-1][j+2] == resultImage[i][j+2]))
  360. 						{
  361. 							blocked = true;
  362. 						}
  363. 					}
  364.  
  365. 					if (!blocked)
  366. 					{
  367. 						resultImage[i][j+2] = resultImage[i][j];						
  368. 					}
  369. 				}			   
  370. 			}
  371.  
  372. 			// ver |
  373. 			//	  \|/
  374. 			if (i + 4 < h)
  375. 			{
  376. 				if ((resultImage[i][j] == resultImage[i+1][j]) &&				   
  377. 					(resultImage[i][j] != resultImage[i+2][j]) &&
  378. 

    					(resultImage[i][j] == resultImage[
i+3][j]) &&
  379. 					(resultImage[i][j] == resultImage[i+4][j]))
  380. 				{
  381. 					bool blocked = false;
  382.  
  383. 					if (testBlocked)
  384. 					{
  385. 						if ((j + 1 < w) && 
  386. 							(resultImage[i+2][j+1] == resultImage[i+2][j]))
  387. 						{
  388. 							blocked = true;
  389. 						}
  390.  
  391. 						if ((i - 1 > 0) && 
  392. 							(resultImage[i+2][j-1] == resultImage[i+2][j]))
  393. 						{
  394. 							blocked = true;
  395. 						}
  396. 					}
  397.  
  398. 					if (!blocked)
  399. 					{
  400. 						resultImage[i+2][j] = resultImage[i][j];						
  401. 					}
  402. 				}			   
  403. 			}
  404. 		}
  405. }
  406.  
  407. bool SameColorAround(int row, int col, int sourcecolor, int thres)
  408. {
  409. 	bool res = false;
  410.  
  411. 	for (int i=-1; i<=+1; i++)
  412. 	{
  413. 		for (int j=-1; j<=+1; j++)
  414. 			if ((i != 0) || (j != 0))
  415. 				if (((i + row) >= 0) && ((i + row) < h) && ((j + col) >= 0) && ((j + col) < w))
  416. 				{
  417. 					if (abs(sourceImage[row][col] - sourceImage[row+i][col+j]) <= thres)
  418. 					{
  419. 						res = true;
  420. 						break;
  421. 					}
  422. 				}
  423.  
  424. 		if (res) break;
  425. 	}
  426. 	
  427. 	return res;
  428. }
  429.  
  430. void Filter(int thres, int sameThres)
  431. {
  432. 	for (int i=0; i<h; i++)
  433. 		for (int j=0; j<w; j++)
  434. 		{
  435. 			int sourcecolor = sourceImage[i][j];
  436. 			int aroundcolor = GetColorForDiffValue(i, j);
  437.  
  438. 			if ((abs(sourcecolor - aroundcolor) > thres) &&
  439. 				(!SameColorAround(i, j, sourcecolor, sameThres)))
  440. 			{
  441. 				diffcount++;
  442.  
  443. 				diffs[diffcount].i = i;
  444. 				diffs[diffcount].j = j;
  445. 				diffs[diffcount].value = abs(sourcecolor - aroundcolor);
  446.  
  447. 				badPoints[i][j] = true;
    448. 

  448. 			}
  449. 		}
  450. }
  451.  
  452. void FilterAvatar(int thres)
  453. {
  454. 	int moda[256];
  455.  
  456. 	for (int i=0; i<h; i++)	
  457. 	{
  458. 		moda[resultImage[i][0]]++;
  459. 		moda[resultImage[i][w-1]]++;		
  460. 	}
  461.  
  462. 	for (int j=0; j<w; j++)
  463. 	{
  464. 		moda[resultImage[0][j]]++;			
  465. 		moda[resultImage[h-1][j]]++;		
  466. 	}
  467.  
  468. 	int best=0, bestcount=0;
  469.  
  470. 	for (int i=0; i<256; i++)
  471. 	{
  472. 		if (moda[i] > bestcount)
  473. 		{
  474. 			bestcount = moda[i];
  475. 			best = i;
  476. 		}
  477. 	}
  478.  
  479. 	if (bestcount > 350)
  480. 	{
  481. 		for (int i=0; i<h; i++)
  482. 		{
  483. 			if (abs(resultImage[i][0] - best) >= thres)
  484. 			{
  485. 				resultImage[i][0] = best;
  486. 			}
  487.  
  488. 			if (abs(resultImage[i][w-1] - best) >= thres)
  489. 			{
  490. 				resultImage[i][w-1] = best;
  491. 			}
  492. 		}
  493.  
  494. 		for (int j=0; j<w; j++)
  495. 		{
  496. 			if (abs(resultImage[0][j] - best) >= thres)
  497. 			{
  498. 				resultImage[0][j] = best;
  499. 			}
  500.  
  501. 			if 
(abs(resultImage[h-1][j] - best) >= thres)
  502. 			{
  503. 				resultImage[h-1][j] = best;
  504. 			}
  505. 		}
  506. 	}
  507. }
  508.  
  509. void Filter2x2Diagonal(int centerThres, int aroundThres, bool centerLighter)
  510. {
  511. 	int a = 1, b = -1;
  512.  
  513. 	if (!centerLighter)
  514. 	{
  515. 		a = -a;
  516. 		b = -b;
  517. 	}
  518.  
  519. 	int matrToUp [4][4] = { {0, 1, 1, 1}, {1, 1, 0, 1}, {1, 0, 1, 1}, {1, 1, 1, 0}};
  520. 	int matrToDown [4][4] = { {1, 1, 1, 0}, {1, 0, 1, 1}, {1, 1, 0, 1}, {0, 1, 1, 1}};
  521.  
  522. 	for (int i=-1; i<=h-3; i++)	
  523. 		for (int j=-1; j<=w-3; j++)
  524. 		{
  525. 			// To up
  526.  			// 
  527. 			if (abs((int)resultImage[i+2][j+1] - (int)resultImage[i+1][j+2]) <= centerThres)
  528. 			{
  529. 				int center = ((int)resultImage[i+2][j+1] + (int)resultImage[i+1][j+2]) / 2;
  530.  
  531. 				bool apply = true;
  532.  
  533. 				for (int ii=0; ii<4; ii++)
  534. 				{
  535. 					for (int jj=0; jj<4; jj++)
  536. 						if (((ii + i) >= 0) && ((ii + i) < h) && ((jj + j) >= 0) && ((jj + j) < w))
  537. 						if ((matrToUp[ii][jj] == 1) &&
  538. 							((a*center + (int)b*resultImage[i+ii][j+jj]) < aroundThres))
  539. 						{
  540. 							apply = false;
  541. 							break;
  542. 						}
  543.  
  544. 					if (!apply) break;
  545. 				}
  546.  
  547. 				if (apply)
  548. 				{
  549. 					badPoints[i+2][j+1] = true;
  550. 					badPoints[i+1][j+2] = true;
  551.  
  552. 					resultImage[i+2][j+1] = MedianColor(i+2, j+1, false);
  553. 					resultImage[i+1][j+2] = MedianColor(i+
1, j+2, false);
  554.  
  555. 					badPoints[i+2][j+1] = false;
  556. 					badPoints[i+1][j+2] = false;
  557. 				}
  558. 			}
  559.  
  560. 			// To down
  561.  			// 
  562. 			if (abs((int)resultImage[i+1][j+1] - (int)resultImage[i+2][j+2]) <= centerThres)
  563. 			{
  564. 				int center = ((int)resultImage[i+1][j+1] + (int)resultImage[i+2][j+2]) / 2;
  565.  
  566. 				bool apply = true;
  567.  
  568. 				for (int ii=0; ii<4; ii++)
  569. 				{
  570. 					for (int jj=0; jj<4; jj++)
  571. 						if (((ii + i) >= 0) && ((ii + i) < h) && ((jj + j) >= 0) && ((jj + j) < w))
  572. 						if ((
matrToDown[ii][jj] == 1) &&
  573. 							((a*center + (int)b*resultImage[i+ii][j+jj]) < aroundThres))
  574. 						{
  575. 							apply = false;
  576. 							break;
  577. 						}
  578.  
  579. 					if (!apply) break;
  580. 				}
  581.  
  582. 				if (apply)
  583. 				{
  584. 					badPoints[i+1][j+1] = true;
  585. 					badPoints[i+2][j+2] = true;
  586.  
  587. 					resultImage[i+1][j+1] = MedianColor(i+1, j+1, false);
  588. 					resultImage[i+2][j+2] = MedianColor(i+2, j+2, false);
  589.  
  590. 					badPoints[i+1][j+1] = false;
  591. 					badPoints[i+2][j+2] = false;
  592. 				}
  593. 			}
  594. 		}	
  595. }
  596.  
  597. void Filter2x2Linear(int centerThres, int aroundThres, bool centerLighter)
  598. {
  599. 	int a = 1, b = -1;
  600.  
  601. 	if (!centerLighter)
  602. 	{
  603. 		a = -a;
  604. 		b = -b;
  605. 	}
  606.  
  607. 	int matrHor [3][4] = { {1, 1, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}};
  608. 	int matrVer [4][3] = { {1, 1, 1}, {1, 0, 1}, {1, 0, 1}, {1, 1, 1}};
  609.  
  610. 	for (int i=-1; i<=h-2; i++)	
  611. 		for (int j=-1; j<=w-3; j++)
  612. 		{
  613. 			// Hor
  614.  			// 
  615. 			if (abs((int)resultImage[i+1][j+1] - (int)resultImage[i+1][j+2]) <= centerThres)
  616. 			{
  617. 				int center = ((int)resultImage[i+1][j+1] + (int)resultImage[i+1][j+2]) / 2;
  618.  
  619. 				bool apply = true;
  620.  
  621. 				for (int ii=0; ii<3; ii++)
  622. 				{
  623. 					for (int jj=0; jj<4; jj++)
  624. 						if (((ii + i) >= 0) && ((ii + i) < h) && ((jj + j) >= 0) && ((jj + j) < w))
  625. 						if ((matrHor[ii][jj] == 1) &&
  626. 				
			((a*center + (int)b*resultImage[i+ii][j+jj]) < aroundThres))
  627. 						{
  628. 							apply = false;
  629. 							break;
  630. 						}
  631.  
  632. 					if (!apply) break;
  633. 				}
  634.  
  635. 				if (apply)
  636. 				{
  637. 					badPoints[i+1][j+1] = true;
  638. 					badPoints[i+1][j+2] = true;
  639.  
  640. 					resultImage[i+1][j+1] = MedianColor(i+1, j+1, false);
  641. 					resultImage[i+1][j+2] = MedianColor(i+1, j+2, false);
  642.  
  643. 					badPoints[i+1][j+1] = false;
  644. 					badPoints[i+1][j+2] = false;
  645. 				}
  646. 			}
  647. 		}
  648.  
  649. 	for (int i=-1; i<=h-3; i++)	
  650. 		for (int j=-1; j<=w-2; j++)
  651. 		{
  652. 			// Ver
  653.  			// 
  654. 			if (abs((int)resultImage[i+1][j+1] - (int)resultImage[i+2][j+1]) <= centerThres)
  655. 			{
  656. 				int center = ((int)resultImage[i+1][j+1] + (int)resultImage[i+2][j+1]) / 2;
  657.  
  658. 				bool apply = true;
  659.  
  660. 				for (int ii=0; ii<4; ii++)
  661. 				{
  662. 					for (int jj=0; jj<3; jj++)
  663. 						if (((ii + i) >= 0) && ((ii + i) < h) && ((jj + j) >= 0) && ((jj + j) < w))
  664. 						if ((
matrVer[ii][jj] == 1) &&
  665. 							((a*center + (int)b*resultImage[i+ii][j+jj]) < aroundThres))
  666. 						{
  667. 							apply = false;
  668. 							break;
  669. 						}
  670.  
  671. 					if (!apply) break;
  672. 				}
  673.  
  674. 				if (apply)
  675. 				{
  676. 					badPoints[i+1][j+1] = true;
  677. 					badPoints[i+2][j+1] = true;
  678.  
  679. 					resultImage[i+1][j+1] = MedianColor(i+1, j+1, false);
  680. 					resultImage[i+2][j+1] = MedianColor(i+2, j+1, false);
  681.  
  682. 					badPoints[i+1][j+1] = false;
  683. 					badPoints[i+2][j+1] = false;
  684. 				}
  685. 			}
  686. 		}	
  687. }
  688.  
  689. void Filter2x2()
  690. {
  691. 	Filter2x2Diagonal(8, 35, false);
  692. 	Filter2x2Diagonal(8, 35, true);
  693.  
  694. 	Filter2x2Linear(8, 35, false);
  695. 	Filter2x2Linear(8, 35, true);
  696. }
  697.  
  698. int main(void)
  699. {
  700. 	int t;	
  701.  
  702. 	scanf("%d", &t);
  703.  
  704. 	for (int tt=0; tt<t; tt++)
  705. 	{
  706. 		ClearBadPoints();
  707.  
  708. 		scanf("%d %d %d", &q, &h, &w);
  709.  
  710. 		ReadImage();
  711.  
  712. 		diffcount = 0;
  713. 		CopySourceToResult();
  714.  
  715. 		int thres = 14 - q/2;
  716. 		
  717. 		/*
  718. 		do 
  719. 		{			
  720. 			ClearBadPoints();
  721. 			diffcount = 0;
  722. 			CopyResultToSource();
  723. 			FilterSinglePoints(thres);
  724. 			ApplyDiffs();
  725. 		} while (diffcount > 3);
  726. 		*/
  727.  
  728. 		// Some filter
  729. 		
  730. 		ClearBadPoints();
  731. 		diffcount = 0;
  732. 		CopyResultToSource();
  733.  
  734. 		int diffthres = 120;
  735. 		
  736. 		int samethres = 0;//12 - q/2;
  737. 		if (samethres < 0) samethres = 0;
  738.  
  739. 		//Filter(diffthres, samethres);
  740. 		//ApplyDiffs();
  741. 		
  742. 		do 
  743. 		{			
  744. 			ClearBadPoints();
  745. 			diffcount = 0;
  746. 			CopyResultToSource();
  747. 			FilterSinglePoints(thres+1);
  748. 			ApplyDiffs();
  749. 		} while (diffcount > 3);
  750. 		
  751. 		// It's ok
  752. 		
  753. 		FillLines(h+w <= 100);
  754. 		FillLines(h+w <= 100);
  755. 		FillLines(h+w <= 100);
  756.  
  757. 		// It's ok too
  758. 		
  759. 		Filter2x2();
  760. 			
  761. 		if
 (q > 3)
  762. 		do
  763. 		{			
  764. 			ClearBadPoints();
  765. 			diffcount = 0;
  766. 			CopyResultToSource();
  767. 			FilterSinglePoints(thres);
  768. 			ApplyDiffs();
  769. 		} while (diffcount > 3);
  770.  
  771. 		/*
  772. 		if ((h == 100) && (w == 100))
  773. 		{
  774. 			FilterAvatar(10);
  775. 		}
  776. 		*/
  777.  
  778. 		if (tt > 0) printf("\n");
  779.  
  780. 		WriteImage();
  781. 	}
  782. }