WLC_Programming Knowledge

C# - Gnome Sort

Posted by ေတဇာလင္း Monday, 25 December 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ဒီေန႔ Gnome Sort ဆိုတဲ့ Sorting Algorithm ေလးတစ္ခုအေၾကာင္းကို ေလ့လာၾကည့္ပါမယ္။ Gnome Sort ကို Stupid Sort လို႔လည္း ေခၚၾကပါေသးတယ္ဗ်။ ဒီ Algorithm ကေတာ့ ဥယ်ာဥ္တစ္ခုအတြင္းမွာ ပန္းအိုးေတြကို အစီအစဥ္တက် စီယူတဲ့အေပၚ အေျခခံထားပါတယ္။

Gnome Sort Algorithm

int i = 1;
while (i < array.Length;) { 
    if (array [i - 1] <= array[i]) {
   ++i; 
    } else { 
         swap(array [i], array [i-1]); 
         --i; 
    if (i == 0) i = 1; 
    } 
}

အလုပ္ လုပ္သြားတဲ့ ပံုကေတာ့ Insertion Sort နဲ႔ Bubble Sort ကို ေပါင္းစပ္ အသံုးျပဳထားတာနဲ႔ အလားသ႑န္တူပါတယ္။ ဒီေကာင္က Sorting စီရာမွာ ကပ္လွ်က္ Element ႏွစ္လံုးကို ႏိႈင္းယွဥ္ပါတယ္။ ႏိႈင္းယွဥ္ခံ Element ႏွစ္ခုအတြင္း ျခားနားခ်က္ရွိသြားၿပီး တစ္နည္းအားျဖင့္ else(Condition) မွန္သြားၿပီ ဆိုရင္ေတာ့ Element ႏွစ္ခုကို ေနရာခ်ိန္းယူပါတယ္။ ေနာက္ၿပီး loop ကို else(Condition) မွားသည္အထိ backwards(i--) ျပန္သြားၿပီး left order Element ေတြနဲ႔ ျပန္ႏိႈင္းယွဥ္ ၾကည့္ပါတယ္ဗ်။ If(Condition) ျပန္မွန္တဲ့အခ်ိန္ေရာက္ရင္ေတာ့ Right order Element ေတြနဲ႔ တစ္ခါျပန္ႏႈိင္းယွဥ္ၿပီး Algorithm ကို ဆက္အလုပ္ လုပ္ပါတယ္ဗ်။ ဒီသေဘာတရားအတိုင္း Sorted List မျဖစ္မျခင္း Algorithm ကို ထပ္ခါတလဲလဲ အလုပ္ လုပ္ေစမွာ ျဖစ္ပါတယ္။ ငယ္စဥ္ႀကီးလိုက္အတြက္ Algorithm အလုပ္ လုပ္သြားပံုကို က်ေနာ္တို႔ ဥပမာေလးနဲ႔ ေလ့လာၾကည့္ပါ့မယ္။

နားလည္ႏိုင္ၾကလိမ့္မယ္လို႔ ထင္ပါတယ္ဗ်ာ။

Time Complexity :

For only one Loop  : O(n)  
For Variable Index  : O(n^2) -gets incremented and decremented

ဒီ Algorithm ကေတာ့ Stupid Sort အမ်ိဳးအစားထဲမွာပါေပမဲ့ Sorting Method ေတြထဲမွာ Adaptive ျဖစ္ၿပီး သံုးသင့္တဲ့ ထဲမွာပါ၀င္ပါတယ္ဗ်။ Processing Time ၾကာတယ္/မၾကာဘူးကေတာ့ အသံုးျပဳမယ့္ Array/List အေပၚမွာ မူတည္ပါလိမ့္မယ္။ Algorithm ကိုက loop တစ္ခုအတြင္းမွာ increase and decrease ႏွစ္မ်ိဳးစလံုးကို သံုးထားတာကိုး။ ဒါေၾကာင့္ အသံုးျပဳမည့္ Array/List မွာ Sorted ျဖစ္ၿပီးသား Element ေတြ မ်ားမ်ား order ျဖစ္ေနရင္ Processing Time ျမန္မွာျဖစ္ၿပီး မဟုတ္ရင္ေတာ့ ၾကာႏိုင္ပါလိမ့္မယ္ဗ်။

ကဲ… ေသခ်ာနားလည္သြားေအာင္ ေအာက္မွာ C# နဲ႔ေရးထားတဲ့ ကုဒ္အျပည့္အစံုေလးကို ေလ့လာၾကည့္ၾကစို႔ဗ်ာ။

using System;
using System.Diagnostics;

namespace SortingMethods
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] data = { -1, 925, -58, 885, -11, -525, -6,100,10,1,31,-45 };
            Stopwatch sw = new Stopwatch();
            sw.Start();
            Console.WriteLine("Gnome Sort Algorithm\n=======================\n");
            Console.WriteLine("UnSorted Array");
            printArray(data);

            Console.WriteLine("\n\nSorted Array");
            GnomeSort(ref data);
            printArray(data);

            Console.WriteLine("\n\nProcessing Time: \n\t" + sw.Elapsed.ToString("c"));
            sw.Stop();
            Console.ReadKey();
        }

        static void printArray(int[] arr)
        {
            int len = arr.Length;
            for (int i = 0; i < len; i++) {
                Console.Write(arr[i] + ", ");
            }
        }

        private static void GnomeSort(ref int[] data)
        {
            int i = 1;
            while (i < data.Length) {
                int tmp;
                if (data[i-1] <= data[i]) { i++; }
                else {
                    tmp = data[i - 1];
                    data[i - 1] = data[i];
                    data[i] = tmp;
                    i--;

                    if (i==0) { i = 1; }
                }
            }
        }       
    }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Bogo Sort

Posted by ေတဇာလင္း Wednesday, 20 December 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ဒီေန႔ Bogo Sort ဆိုတဲ့ Sorting Algorithm ေလးတစ္ခုအေၾကာင္းကို ေလ့လာၾကည့္ပါမယ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Bogo Sort ကိုေတာ့…

 Permutation Sort, 
 Stupid Sort, 
 Slow Sort, 
 Shotgun Sort  or 
 Monkey Sort

ဆိုၿပီး အမ်ိဳးမ်ိဳး ေခၚေ၀ၚၾကပါတယ္။ ေခါင္းစဥ္ခြဲေတြကို ၾကည့္လိုက္တာနဲ႔တင္ Bogo Sort ရဲ႕ အက်ိဳးသက္ေရာက္မႈကို သိႏိုင္ပါလိမ့္မယ္။ ဒီေကာင္က အစီအစဥ္က်နစြာ အလုပ္,လုပ္ျခင္းမ်ိဳးမဟုတ္ဘဲ မ်က္ကန္းလမ္းေလွ်ာက္ ဆန္ေနပါတယ္။ Key Generator တစ္ခုက ခ်ေပးလိုက္တဲ့ ကိန္းစဥ္တန္းေပၚမူတည္ၿပီး Sorted List ျဖစ္/မျဖစ္ စစ္ပါတယ္။ Sorted List မျဖစ္မျခင္း ကိန္းစဥ္တန္းကို Key Generator ကိုျဖတ္ခိုင္းၿပီး ေနာက္တစ္ဖန္ Input အတြက္ ကိန္းစဥ္တန္းတစ္ခု Generate လုပ္ယူပါတယ္။ Sorted List ျဖစ္သြားမွသာ ရပ္တန္႔သြားမွာျဖစ္ပါတယ္။ Key Generator ကလည္း Random သေဘာ အလုပ္,လုပ္ေနတာျဖစ္တဲ့အတြက္ လက္ေတြ႔အရ အန္စာတုံးေခါက္ယူတာနဲ႔ ဆင္တူပါတယ္။

Pseudocode ကေတာ့ ရိုးရွင္းပါတယ္။ ေအာက္မွာ ေလ့လာၾကည့္လိုက္ပါ။

while not Sorted(list) do
    shuffle(list)
done

Example:
Let us consider an example array (3 2 5 1 0 4)
4 5 0 3 2 1 (1st shuffling)
4 1 3 2 5 0 (2nd shuffling)
1 0 3 2 5 4 (3rd shuffling)
3 1 0 2 4 5 (4th shuffling)
1 4 5 0 3 2 (5th shuffling)
.
.
.
0 1 2 3 4 5 (nth shuffling)—— Sorted Array

Pseudocode နဲ႔ Exmaple ကိုၾကည့္လိုက္ရင္ေတာ့ Bogo Sort ရဲ႕ အလုပ္ လုပ္သြားပံုကို အနည္းငယ္ နားလည္ႏိုင္လိမ့္မယ္ ထင္ပါတယ္။ အန္စာတံုး ဥပမာနဲ႔ ျပန္ေျပာရရင္ေတာ့… 1. Shuffle( ) function ထဲမွာ ကိန္းစဥ္တန္း အေရအတြက္အတိုင္း အန္စာေခါက္မယ္၊ ရလာတဲ့ ကိန္းေတြကို အစဥ္တိုင္း ခ်ေရးမယ္၊ ၿပီးရင္ေတာ့ Sorted( ) function ကို Sorted List ျဖစ္/မျဖစ္ အစစ္ေဆးခံနိုင္ရန္ ပို႔ေပး ရပါတယ္။ 2. Sorted( ) function ကေတာ့ Shuffle( ) function က Generate လုပ္ၿပီး ပို႔လာတဲ့ ကိန္းစဥ္တန္းကို Sorted List ျဖစ္/မျဖစ္ ကိန္းလံုး အခ်င္းခ်င္း ႏႈိင္းယွဥ္ၿပီး စစ္ေဆးပါတယ္။ Sorted List ျဖစ္တယ္ဆို ရင္ေတာ့ End ကိုခုန္ၿပီး Sorted List ကို ထုတ္ျပေပးပါတယ္။ Sorted List မျဖစ္ခဲ့ရင္ေတာ့ အဆင့္(၁)၊ Shuffle( ) function ကိုျပန္သြားေစၿပီး ေနာက္တစ္ႀကိမ္ Input အတြက္ ကိန္းစဥ္တန္းကို Generate ထပ္လုပ္ခုိင္းပါတယ္။ ဒီသေဘာတရားအတိုင္း Sorted List မျဖစ္မျခင္း Algorithm ကို ထပ္ခါတလဲလဲ အလုပ္ လုပ္ေစမွာ ျဖစ္ပါတယ္။ Time Complexity ကေတာ့ ေအာက္ပါအတိုင္းပါပဲဗ်ာ။

Worst Case  : O(∞)  (since this algorithm has no upper bound)
Average Case : O(n*n!)
Best Case   : O(n) (when array given is already sorted)

အလုပ္ လုပ္ေနမယ့္ Shuffling ကေတာ့ အကန္႔အသတ္မရွိ n အႀကိမ္ေျမာက္ထိ ျဖစ္ႏိုင္ပါတယ္။ ဒါေၾကာင့္ အသံုးျပဳသင့္တဲ့ Sorting Algorithm တစ္ခုေတာ့ မဟုတ္ပါဘူး။ အျခားေသာ Algorithm ေတြနဲ႔ ႏႈိင္းယွဥ္ ေဖာ္ျပဖို႔အတြက္ ပညာေရးဆိုင္ရာ နယ္ပယ္ေတြမွာ သီအိုရီအရ သိသင့္တဲ့ Sorting Method တစ္ခုလို႔ပဲ ေျပာပါ ရေစ။ မွတ္ခ်က္။ ။ ၆ မ်က္ႏွာပဲရွိတဲ့ အန္စာတံုးမွာေတာင္မွ မိမိလိုခ်င္တဲ့ ကိန္းတစ္ခုကို ရဖို႔ အႀကိမ္အေတာ္ ၾကာၾကာ ေခါက္ယူရတာျဖစ္တဲ့အတြက္ Bogo Sort ရဲ႕ ကိန္းစဥ္တန္းဟာလည္း မ်ားရင္ မ်ားသလို Shuffling အႀကိမ္အေရအတြက္ ပိုမ်ားႏိုင္ၿပီး Compile Time ပိုၾကာႏိုင္ပါတယ္။ ဒါေပသိ ကိန္းစဥ္တန္းကို Generator နဲ႔ ထုတ္ေပးေနတာျဖစ္လို႔ ကံအေၾကာင္း သင့္ခဲ့ရင္ေတာ့ Sorted List ကို Shuffling အႀကိမ္ အနည္းငယ္အတြင္း မွာလည္း ရႏိုင္ပါတယ္ဗ်။

ေအာက္မွာ C# Code အျပည့္အစံုေလးကို ပိုနားလည္သြားေအာင္ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။

using System;
using System.Diagnostics;

namespace BogoSort
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] data = { -1, 25, -58, 85, -11, 25, 6 };
            Stopwatch sw = new Stopwatch();
            sw.Start();            
            Console.WriteLine("UnSorted Array");
            printArray(data);

            Console.WriteLine("\n\nSorted Array");
            BogoSort(ref data);            
            printArray(data);

            Console.WriteLine("\n\nProcessing Time: \n\t" + sw.Elapsed.ToString("c"));
            sw.Stop();
            Console.ReadKey();
        }

        static void printArray(int[] arr)
        {
            int len = arr.Length;
            for (int i = 0; i < len; i++) {
                Console.Write(arr[i] + ", ");
            }
        }

        public static void BogoSort(ref int[] data)
        {
            while (!IsSorted(ref data)) {
                Shuffle(ref data);
            }
        }

        private static bool IsSorted(ref int[] data)
        {
            int count = data.Length;
            while (--count >= 1) {
                if (data[count] < data[count - 1]) {
                    return false;
                }                
            }
            return true;
        }

        private static void Shuffle(ref int[] data)
        {
            int temp, rnd;
            Random rand = new Random();
            for (int i = 0; i < data.Length; ++i) {
                rnd = rand.Next(data.Length);
                temp = data[i];
                data[i] = data[rnd];
                data[rnd] = temp;
            }
        }        
    }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# Setup with Smart Installer Maker

Posted by ေတဇာလင္း Thursday, 29 June 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Smart Installer Maker ကိုအသံုးျပဳၿပီး Setup Installer File ေလး ဖန္တီးႏိုင္တာေလးကို ေႏြးေဆြးေပးသြားပါ့မယ္။ က်ေနာ္ C# နဲ႔ ေရးထားတဲ့ Project ကုိ အသံုးျပဳသြားပါ့မယ္ဗ်။ Visual Studio မွာ Installer file ကို တန္းထုတ္လို႔ ရပါတယ္။ ဒါေပမဲ့ မသိတဲ့ မိတ္ေဆြတို႔အတြက္ အနည္းငယ္ ခက္ခဲေနပါလိမ့္မယ္။ ဒီ Smart Installer Maker ေလးကေတာ့ Setup File ထုတ္ဖို႔ သီးသန္႔ ဖန္တီးထားတဲ့ App ျဖစ္လို႔ အသံုးျပဳရ အရမ္းလြယ္ကူပါတယ္။ Setup File ထုတ္ယူတာကို ေမးတဲ့လူေတြကလည္း အရမ္း မ်ားေနတာေၾကာင့္ အခုလို တင္ျပရျခင္းျဖစ္ပါတယ္ဗ်။ စိတ္၀င္စားၾကတဲ့ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား က်ေနာ္နဲ႔ ေအာက္က pdf file ေလးမွာ ေလ့လာၾကည့္ၾကဖို႔ ဖိတ္ေခၚပါတယ္ဗ်ာ။
က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းခဲ့တာမ်ား ရွိခဲ့ရင္ ျဖည့္စြတ္ နားလည္ေပးၾကဖို႔ ေမတၱာရပ္ခံပါတယ္ဗ်ာ။
အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။

2. Digital Signal Processing (DSP) – Signal Representation

Posted by ေတဇာလင္း Tuesday, 28 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Digital Signal Processing ဆိုတဲ့ DSP အေျခခံ Knowledge အပိုင္း(၂)ေလးျဖစ္တဲ့ Signal ေတြကို ကုိယ္စားျပဳေဖာ္ျပျခင္း (Signal Representation) အေၾကာင္းကို ေဆြးေႏြးေပးခ်င္ပါတယ္။ ေယဘူယ်အားျဖင့္ေတာ့ Signal ေတြကို Mathematical Representation နဲ႔ Graphical Representation ဆိုၿပီး ကိုယ္စားျပဳအသြင္ (၂)မ်ိဳးနဲ႔ ေဖာ္ျပေလ့ရွိပါတယ္။

တကယ္ေတာ့ DSP ရဲ႕ Language က Mathematics ပါပဲ။ Mathematics ရဲ႕ alphabet ေတြက ကိန္းဂဏန္းေတြ၊ Formula ေတြ၊ equation ေတြပဲမို႔ familiar ျဖစ္ရေတာ့မယ္။ စတင္ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတယ္။ အဓိပၸါယ္ ကြဲလြဲခဲ့တာမ်ားရွိရင္ နားလည္ေပးၾကဖို႔နဲ႔ ျပန္လည္ ေထာက္ျပေပးၾကဖုိ႔လည္း ေမွ်ာ္လင့္ပါတယ္ဗ်။ ဒီေန႔ ေဆြးေႏြးမႈမွာေတာ့ အရိုးရွင္းဆံုး အသံလႈိင္း(sound wave or sound signal)ကို representation (၂)မ်ဳိးနဲ႔ ေလ့လာၾကည့္သြားၾကမွာပါ။ စိတ္၀င္စားတဲ့ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား က်ေနာ္နဲ႔အတူ ေအာက္က PDF File ေလးမွာ အတူေလ့လာၾကစို႔ဗ်ာ။
ဒါကေတာ့ က်ေနာ္ Note 4 ခုအတြက္ Result ထုတ္ျပထားတဲ့ အသံဖိုင္ ေတြပဲျဖစ္ပါတယ္။
အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။

Introduction to Digital Signal Processing (DSP)

Posted by ေတဇာလင္း Friday, 24 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Digital Signal Processing ဆိုတဲ့ DSP အေျခခံ Knowledge ေလးကို ေဆြးေႏြးေပးခ်င္ပါတယ္။ စတင္ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတယ္။ အဓိပၸါယ္ ကြဲလြဲခဲ့တာမ်ားရွိရင္ နားလည္ေပးၾကဖို႔နဲ႔ ျပန္လည္ ေထာက္ျပေပးၾကဖုိ႔လည္း ေမွ်ာ္လင့္ပါတယ္ဗ်။

Digital Signal Processing ကို မေလ့လာမွီ Signal ဆိုတာဘာလဲ?။ Signal Processing ဆိုတာကေရာ ဘာလဲ? ဆိုတာကို သိထားဖို႔ လိုအပ္ပါတယ္။ Signal ဆိုတာ က်ေနာ္တို႔ရဲ႕ ေန႔စဥ္လူေနမႈဘ၀မွာ အေရးႀကီးတဲ့ အခန္းက႑ကေန ပါ၀င္ေနပါတယ္ဗ်။ ဥပမာ- က်ေနာ္တို႔ စကားေျပာတယ္ဆိုပါစို႔။ ထြက္လာတဲ့ အသံ(Voice)မွာ ေျပာခ်င္တဲ့ အေၾကာင္းအရာ စကားလံုး(Speech)ကို နားေထာင္ၿပီး ျပန္လည္တုန္႔ျပန္ လုပ္ေဆာင္ၾကပါတယ္။ တကယ္ေတာ့ က်ေနာ္တို႔ ေျပာလိုက္တဲ့ စကား(Speech)ဆိုတာ Signal တစ္ခုပါပဲ။ .... စိတ္၀င္စားတဲ့ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား က်ေနာ္နဲ႔အတူ ေအာက္က PDF File ေလးမွာ အတူေလ့လာၾကစို႔ဗ်ာ။
အားလံုးအဆင္ေျပ ေခ်ာေမြ႕နိုင္ၾကပါေစ။

C# - Image Processing (Pink Color Filtering Algorithm)

Posted by ေတဇာလင္း Thursday, 16 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ Image တစ္ခုအတြင္းမွာရွိတဲ့ Pink Color ႏွင့္ ၄င္းနဲ႔အနီးစပ္ဆံုးတူတဲ့ Color ေတြကို Detect လုပ္ယူႏိုင္တာေလးနဲ႔ ပါတ္သတ္ၿပီး ေလ့လာၾကည့္ပါ့မရ္။ Image and Color Filtering ေတြထဲက တစ္ခုေပါ့။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Algorithm ရဲ႕ သေဘာတရားကေတာ့ ရိုးရွင္းပါတရ္။ Image ရဲ႕ Pixel တိုင္းကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ပါတရ္။ ရရွိလာတဲ့ RGB Color Value ေတြကိုမွ Pink Filter Alogrithm ကိုျဖတ္ခိုင္းၿပီး Pink Color ဟုတ္/မဟုတ္ကို စစ္ေဆးပါတရ္။ Pink Color ျဖစ္ခဲ့ရင္ေတာ့ ၄င္း Pixel ကို RGB(255, 255, 255) အစားသြင္းၿပီး အျဖဴေရာင္ျဖစ္ Assign လုပ္ပါတရ္။ Pink Color မဟုတ္ခဲ့ရင္ေတာ့ RGB(0, 0, 0) အစားသြင္းကာ Pixel ကို အမဲေရာင္ျဖစ္ ျပန္ Assign လုပ္ပါတရ္ဗ်။ Result Screen Shoot ေတြကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔ နားလည္သြားၾက လိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်။ Algorithm ရဲ႕ လုပ္ငန္းစဥ္ေတြကေတာ့ ေအာက္ပါအတိုင္းပဲျဖစ္ပါတရ္ဗ်။

 Algorithm:
  1. Get the RGB value of the Detected pixel.
  2. Calculate new RGB values as follows:
    R = originalRedColor;
    G = originalGreenColor + 60;
    B = originalBlueColor – 20;
    If(R > G && R > B)
      Pixel(newRGB) = RGB(255,255,255);
    Else
      Pixel(newRGB)= RGB(0,0,0);
3. Replace the R, G and B value of the pixel with the values calculated in step 2.
4. Repeat Step 1 to Step 3 for each pixels of the image.

Example:
  Detected Pixel = RGB(255, 105, 180);
  Pink Filter Processing =>
    R = 255;
    G = 105 + 60 = 165;
    B = 180 – 20 = 160;
    If(255 > 165 && 255 > 160)
      Pixel(newRGB) = RGB(255,255,255);

Pink Color Filter ဖမ္းယူျခင္းအတြက္ က်ေနာ္ Example မွာ pixel တစ္ခုစာ တြက္ျပထားပါတရ္။ အနည္းငယ္ ရွင္းျပရမရ္ ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ယူပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ Detect ရရွိေသာ RGB တန္ဖိုးေတြကို Pink Color ဟုတ္/မဟုတ္ စစ္ေဆးရန္ Pink Filter Algorithm ထဲကိုျဖတ္ပါတရ္။ Red > Green+60 နဲ႔ Red > Blue-20 က ဒီ Algorithm ရဲ႕ အဓီကအသက္ပါ။ ဒီ Condition ႏွစ္ခုစလံုးမွန္ခဲ့မွသာလွ်င္ Pink Color ပါလို႔မွတ္ယူၿပီး Detected Pixel ကို အျဖဴေရာင္ Color နဲ႔ ဖမ္းယူမွာျဖစ္ပါတရ္။ Condition ႏွစ္ခုထဲက တစ္ခုခု မွားခဲ့ရင္ေတာ့ Pink Color မဟုတ္ဘူးဆိုတာ Auto သိၿပီး Detected Pixel ကို အမဲေရာင္ Color နဲ႔ ဖမ္းယူမွာျဖစ္ပါတရ္။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး Pink Color Filter လုပ္ၿပီးသား Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။
မွတ္ခ်က္။ ေအာက္ပါ Pink Color ရဲ႕ RGB Value ကို ေလ့လာႏိုင္ပါတရ္။

Pink Color Value နဲ႔ Algorithm ကိုၾကည့္ရင္ က်ေနာ္တို႔ ဒီ Algorithm ဟာ အထက္ပါပံုက Pink Color ေတြကိုသာ အတိအက် Detect လုပ္တာ မဟုတ္ဘူးဆိုတာကို ေတြ႔ရမွာပါ။ Pixel ကို Detect လုပ္တဲ့အခါ Color Value ေတြဟာ အရမ္းကို Sensitive ျဖစ္လြန္းတာေၾကာင့္ အနီးစပ္ဆံုး ဒီ Algorithm နဲ႔ စစ္ထုတ္ၿပီး Pink Color ကို ဆြဲထုတ္တာပါဗ်။ တိတိက်က် Pink Color ေတြႀကီး ဆြဲထုတ္ခ်င္ရင္ေတာ့ Detect လုပ္မိတဲ့ RGB Color Value ေတြဟာ အထက္ပါပံုက Pink Color တန္ဖိုးေတြနဲ႔ ညီ/မညီ Condition ေတြနဲ႔ စစ္ထုတ္ႏိုင္ပါတရ္။ ဒီနည္းအတိုင္းပါပဲ မည္သည့္ Color ကုိမဆို စစ္ထုတ္ႏိုင္ပါလိမ့္မရ္ဗ်။

ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ Processing ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ GUI ေဖာက္ Coding ေရးၿပီး လက္ေတြ႔ေလ့လာၾကည့္ရေအာင္။ ဒါကေတာ့ က်ေနာ္တို႔ Project မွာ အသံုးျပဳမရ္ Library File ေတြပါ။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(2)ခုနဲ႔ PictureBox(2)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။

က်ေနာ္ကေတာ့ ေအာက္ကပံုအတိုင္း ပံုစံခ်ထားပါတရ္ဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ GUI ကို ႀကိဳက္သလို ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္ဗ်။

Pink Filter Image ေျပာင္းလဲယူမရ္႕ Method ကိုေတာ့ Button ရဲ႕ Click_Event ထဲမွာေရးပါတရ္။ ဒါေၾကာင့္ Pink Detect Button ကို D-Click ေပးၿပီး ေအာက္ပါ Coding ကုိေရးယူလိုက္ပါဗ်ာ။

public Image PinkDetection(Image inputImg)
{
  Bitmap cloneImg = new Bitmap(inputImg);
  Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
  BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
  unsafe {
    byte* ptrAddress = (byte*)bmpData.Scan0;
    for (int y = 0; y < bmpData.Height; y++) {
      byte* currentAddress = ptrAddress + (y * bmpData.Stride);
      for (int x = 0; x < bmpData.Stride; x+=3) {
        int r, g, b, pink;
        r = currentAddress[x + 2];
        g = currentAddress[x + 1] + 60;
        b = currentAddress[x] - 20;
        pink = ((r > g) && (r > b)) ? 255 : 0;
        currentAddress[x] = currentAddress[x + 1] = currentAddress[x + 2] = (byte)pink;
      }
    }
  }
  cloneImg.UnlockBits(bmpData);
  return cloneImg;
}

Method ကိုေတာ့ Processing လုပ္မရ္႕ Image ကို Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ Pink Filter Image အလုပ္လုပ္သြားပံု အဆင့္ဆင့္ကိုလည္း က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။

က်ေနာ္ Processing ႏွစ္မ်ိဳးနဲ႔ Screen Shoot လုပ္ျပထားပါတရ္။ ေရွ႕ဆက္ၿပီး Calling Method ေလးကို ဆက္ေလ့လာၾကည့္ၾကမရ္ဗ်ာ။

private void btnPinkDetect_Click(object sender, EventArgs e)
{
  if (picOriginalImg.Image != null) {
    picResultImg.Image = PinkDetection(picOriginalImg.Image);
  }
}

ဒါကေေတာ့ Calling Method အေျခအေနပါ။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။

 using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

namespace ImgProcessing
{
  public partial class frmPinkDetection : Form
{
public frmPinkDetection()
{
  InitializeComponent();
}

private void btnLoadImage_Click(object sender, EventArgs e)
{
  LoadImage(picOriginalImg);
}

public void LoadImage(PictureBox pic)
{
  OpenFileDialog openFD = new OpenFileDialog();
  openFD.Title = "Load an Image";
  openFD.Filter = "JPEG Images|*.Jpg|PNG Images|*.Png|GIF Images|*.Gif|BITMAP Images|*.Bmp";
  if (openFD.ShowDialog() == DialogResult.OK) {
    pic.Image = Image.FromFile(openFD.FileName);
  }
}

private void btnPinkDetect_Click(object sender, EventArgs e)
{
  if (picOriginalImg.Image != null) {
    picResultImg.Image = PinkDetection(picOriginalImg.Image);
  }
}

public Image PinkDetection(Image inputImg)
{
  Bitmap cloneImg = new Bitmap(inputImg);
  Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
  BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
  unsafe {
    byte* ptrAddress = (byte*)bmpData.Scan0;
    for (int y = 0; y < bmpData.Height; y++) {
      byte* currentAddress = ptrAddress + (y * bmpData.Stride);
      for (int x = 0; x < bmpData.Stride; x+=3) {
        int r, g, b, pink;
        r = currentAddress[x + 2];
        g = currentAddress[x + 1] + 60;
        b = currentAddress[x] - 20;
        pink = ((r > g) && (r > b)) ? 255 : 0;
        currentAddress[x] = currentAddress[x + 1] = currentAddress[x + 2] = (byte)pink;
      }
    }
  }
  cloneImg.UnlockBits(bmpData);
  return cloneImg;
}
}
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Image Processing (Insert Noise Effect based on Color)

Posted by ေတဇာလင္း Monday, 13 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ မိမိတို႔ ႀကိဳတ္ႏွစ္သက္ရာ Color ကိုအေျခခံၿပီး Image တစ္ခုအတြင္းသို႔ Noise Effect ထည့္သြင္းႏိုင္တာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ Image and Color Filtering ေတြထဲက တစ္ခုေပါ့။ သင္ခန္းစာအားလံုးကေတာ့ series သေဘာမ်ိဳးေလးနဲ႔ တစ္ခုနဲ႔ တစ္ခုဆက္စပ္ေနလို႔ ေရွ႕သင္ခန္းစာေတြကို ေလ့လာေပးၾကဖို႔လည္း တိုက္တြန္းခ်င္ပါတရ္ဗ်။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Algorithm ရဲ႕ သေဘာတရားကေတာ့ က်ေနာ္တို႔ ေရွ႕မွာ ေလ့လာခဲ့တဲ့ Binary Algorithm, Color Substitution Algorithm တို႔ကို အတူတူပါပဲ။ ၄င္း Algorithm ေတြရဲ႕ သေဘာတရားေတြကို အေျခခံၿပီး Threshold Value တစ္ခုန႔ဲ ပိုင္းျခားကာ Pixel ေတြေပၚသို႔ Noise Effect ကို ထည့္သြင္းလိုက္တာပဲျဖစ္ပါတရ္။ Noise ထည့္သြင္းတဲ့ေနရာမွာေတာ့ Binary တုန္းကလို Pixel တိုင္းကို ေျပာင္းလဲမႈမလုပ္ဘဲ Filter ႏွစ္ခုနဲ႔စစ္ထုတ္ကာ Detect လုပ္မိတဲ့ Pixel ကိုသာလွ်င္ Noise ထည့္သြင္းမွာ ျဖစ္ပါတရ္ဗ်။ Result Screen Shoot ေတြကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔ နားလည္သြားၾက လိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်။ Algorithm ရဲ႕ လုပ္ငန္းစဥ္ေတြကေတာ့ ေအာက္ပါအတိုင္းပဲျဖစ္ပါတရ္ဗ်။

Algorithm:
1. Get the RGB value of the Detected pixel.
2. Calculate Average Color Value of Detected Pixel(average = (R+G+B)/3).
3. Convert Color Image to Grayscale.
4. Calculate new RGB values as follows:
          If((average%100)< threshold) 
           If((average%2)== threshold) 
             Pixel(newRGB) = upNoiseColor;
           Else
             Pixel(newRGB)= downNoiseColor;

5. Replace the R, G and B value of the pixel with the values calculated in step 2 to 4.
6. Repeat Step 1 to Step 4 for each pixels of the image.

Example: 
 Detected Pixel = RGB(120, 80, 50);
 averageColor = (120+80+50)/3 = 83;
 Noise Effect Processing => Threshold = 67;
  If((83%100)<67)
    If((83%2)==0)
   ---
    Else
   Pixel(newRGB) = downNoiseColor;

Noise ထည့္သြင္းျခင္းအတြက္ က်ေနာ္ Example မွာ pixel တစ္ခုစာ တြက္ျပထားပါတရ္။ အနည္းငယ္ ရွင္းျပရမရ္ ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ယူပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ Detect ရရွိေသာ RGB တန္ဖိုးေတြရဲ႕ Average တန္ဖိုးကိုရွာၿပီး Grayscale အျဖစ္ေျပာင္းယူပါတရ္။ မိတ္ေဆြတို႔အေနနဲ႔ Color Image ေပၚမွာပဲ Noise ကို ထည့္သြင္းခ်င္တရ္ဆိုရင္ေတာ့ ဒီ Grayscale ေျပာင္းတဲ့အဆင့္ကို ေက်ာ္သြားႏိုင္ပါတရ္။ က်ေနာ္ကေတာ့ ဓါတ္ပံုအေဟာင္းေတြေပၚမွာ Noise ထင္တဲ့ပံုစံမ်ိဳး ေျပာင္းခ်င္လို႔ Grayscale ေျပာင္းယူတဲ့အဆင့္ကို ထည့္သြင္းထားတာပဲျဖစ္ပါတရ္ဗ်။ ေနာက္တစ္အဆင့္မွာေတာ့ ရရွိလာေသာ Average%100 တန္ဖိုးနဲ႔ Threshold Value ကိုႏႈိင္းယွဥ္ၿပီး Filter တစ္ဆင့္ခံပါတရ္။ စစ္ေဆးမႈေအာင္ျမင္ခဲ့ရင္ေတာ့ ဒုတိယ (83%2)==0 Filter ကို ထပ္စစ္ပါတရ္ဗ်။ ဒီ Filter ႏွစ္ခုအေပၚမူတည္ၿပီး Detect လုပ္မိေသာ ဘရ္ Pixel ေပၚကိုေတာ့ upNoiseColor ထည့္မရ္၊ ဘရ္ Pixel ေပၚကိုေတာ့ downNoiseColor ထည့္မရ္ဆိုတာကို သတ္မွတ္တာပါ။ Threshold Value နဲ႔ ပိုင္းျခားထားတဲ့ ပထမ Filter က ဒီ Processing အတြက္ အဓိကျဖစ္ပါတရ္။ ဒီအဆင့္မွာ condition False ျဖစ္ခဲ့ရင္ေတာ့ ၄င္း Detected Pixel ကို မူလ Color အတိုင္း မေျပာင္းလဲပဲ ျပန္ assign လုပ္ေပးမွာျဖစ္ပါတရ္။ ဒါေၾကာင့္ Threshold Value တန္ဖိုးမ်ားေလ က်ေရာက္လာမရ္႕ Noise အေရအတြက္မ်ားလာေလ ျဖစ္မရ္ဆိုတာကို သတိထားေစခ်င္ပါတရ္။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး Noise ထည့္သြင္းၿပီးသား Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(1)ခုနဲ႔ PictureBox(2)ခု၊ Panel(2)၊ Label(1)ခုုနဲ႔ TrackBar(1)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။

က်ေနာ္တို႔ Processing လုပ္မရ္႕ Color အတြက္ Panel Box ႏွစ္ခုကို သံုးထားပါတရ္။ Panel Box ရဲ႕ Click_Event ေတြမွာ ColorDialog Box ေတြကိုေခၚၿပီး မိမိႏွစ္သက္ရာ Color ကိုေရြးခ်ယ္မွာျဖစ္ပါတရ္။ က်ေနာ္ကေတာ့ Color Loading အတြက္ Method ခြဲေရးထားပါတရ္။ ဒါအျပင္ Form_Load တတ္တတ္ခ်င္းမွာ Noise အတြက္ Black and White Color ႏွစ္ခုကို Auto Detect လုပ္ႏိုင္ေအာင္ ဆြဲေခၚထားပါေသးတရ္ဗ်။ ဘာ Color မွ မေရြးပဲ Processing လုပ္မိရင္ Default အေနနဲ႔ Noise ကို Black and White ပံုစံနဲ႔ ထည့္သြင္းေပးႏိုင္ေအာင္ပါဗ်။ ေအာက္မွာ ေလ့လာၾကည့္လုိက္ပါဗ်ာ။

        Color upNoise, downNoise;
        private void frmAddNoiseImage_Load(object sender, EventArgs e)
        {
            pnUpColor.BackColor = Color.Black;
            upNoise = Color.Black;
            pnDownColor.BackColor = Color.White;
            downNoise = Color.White;
        }

        private void pnUpColor_Click(object sender, EventArgs e)
        {
            upNoise = LoadColor();
            pnUpColor.BackColor = upNoise;
        }

        private void pnDownColor_Click(object sender, EventArgs e)
        {
            downNoise = LoadColor();
            pnDownColor.BackColor = downNoise;
        }

        public Color LoadColor()
        {
            ColorDialog colorD = new ColorDialog();
            Color returnColor = Color.Empty;
            if (colorD.ShowDialog() == DialogResult.OK)
            {
                returnColor = colorD.Color;
            }
            return returnColor;
        }

LoadColor()Method နဲ႔ Calling ပံုစံေတြကိုေတာ့ ေရွ႕သင္ခန္းစာမွာ ေလ့လာခဲ့ၿပီးျဖစ္လို႔ ေထြေထြထူးထူး ရွင္းစရာ မလိုေတာ့ဘူးလို႔ ထင္ပါတရ္ဗ်။ အထက္ပါ Coding အားလံုးရဲ႕ ရည္ရြယ္ခ်က္ကေတာ့ Processing လုပ္မဲ့ Specified Color ကို ေရြးခ်ယ္ဖို႔ပါပဲဗ်ာ။ ခက္ခဲတာမပါလို႔ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Noise Effect Image ေျပာင္းလဲယူမရ္႕ Method ကိုေတာ့ TrackBar ရဲ႕ Scroll_Event ထဲမွာေရးပါတရ္။ ဒါေၾကာင့္ TrackBar ရဲ႕ Value ေျပာင္းလဲမႈအေပၚမူတည္ၿပီး Image Result ေျပာင္းလဲမႈရွိပါလိမ့္မရ္ဗ်။

        public Image AddNoiseEffect(Image inputImg, int threshold, Color upNoiseColor, Color downNoiseColor)
        {
            Bitmap cloneImg = new Bitmap(inputImg);
            Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
            BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe
            {
                byte* ptrAddress = (byte*)bmpData.Scan0;
                for (int y = 0; y < bmpData.Height; y++)
                {
                    byte* currentAddress = ptrAddress + (y * bmpData.Stride);
                    for (int x = 0; x < bmpData.Stride; x+=3)
                    {
                        int averageColor = (currentAddress[x] + currentAddress[x + 1] + currentAddress[x + 2]) / 3;
                        currentAddress[x] = currentAddress[x + 1] = currentAddress[x + 2] = (byte)averageColor;
                        if ((averageColor % 100) < threshold) {
                            if ((averageColor % 2) == 0) {
                                currentAddress[x] = upNoiseColor.B;
                                currentAddress[x + 1] = upNoiseColor.G;
                                currentAddress[x + 2] = upNoiseColor.R;
                            } else {
                                currentAddress[x] = downNoiseColor.B;
                                currentAddress[x + 1] = downNoiseColor.G;
                                currentAddress[x + 2] = downNoiseColor.R;
                            }
                        }   
                    }
                }
            }
            cloneImg.UnlockBits(bmpData);
            return cloneImg;
        }

Method ကိုေတာ့ Processing လုပ္မရ္႕ Image, Color Value နဲ႔ Threshold value တို႔ကို Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ Noise Effect Image အလုပ္လုပ္သြားပံု အဆင့္ဆင့္ကိုလည္း က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။

Calling Method ေလးကို ဆက္ၾကည့္ၾကရေအာင္ဗ်ာ။

private void tbThreshold_Scroll(object sender, EventArgs e)
{
   lblThreshold.Text = tbThreshold.Value.ToString();
   if (picOriginalImg.Image != null) {
      picResultImg.Image = AddNoiseEffect(picOriginalImg.Image, tbThreshold.Value,  upNoise, downNoise);
   }            
}

ဒါကေေတာ့ TrackBar Value ေျပာင္းလဲအမႈအေပၚ မူတည္ၿပီး Image Result ေျပာင္းလဲယူဖို႔အတြက္ Calling Method အေျခအေနပါ။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

namespace ImgProcessing
{
    public partial class frmAddNoiseImage : Form
    {
        public frmAddNoiseImage()
        {
            InitializeComponent();
        }

        Color upNoise, downNoise;
        private void frmAddNoiseImage_Load(object sender, EventArgs e)
        {
            pnUpColor.BackColor = Color.Black;
            upNoise = Color.Black;
            pnDownColor.BackColor = Color.White;
            downNoise = Color.White;
        }

        private void pnUpColor_Click(object sender, EventArgs e)
        {
            upNoise = LoadColor();
            pnUpColor.BackColor = upNoise;
        }

        private void pnDownColor_Click(object sender, EventArgs e)
        {
            downNoise = LoadColor();
            pnDownColor.BackColor = downNoise;
        }

        public Color LoadColor()
        {
            ColorDialog colorD = new ColorDialog();
            Color returnColor = Color.Empty;
            if (colorD.ShowDialog() == DialogResult.OK)
            {
                returnColor = colorD.Color;
            }
            return returnColor;
        }

        private void btnLoadImage_Click(object sender, EventArgs e)
        {
            LoadImage(picOriginalImg);
        }

        public void LoadImage(PictureBox pic)
        {
            OpenFileDialog openFD = new OpenFileDialog();
            openFD.Title = "Load an Image";
            openFD.Filter = "JPEG Images|*.Jpg|PNG Images|*.Png|GIF Images|*.Gif|BITMAP Images|*.Bmp";
            if (openFD.ShowDialog() == DialogResult.OK) {
                pic.Image = Image.FromFile(openFD.FileName);
            }
        }
    
        private void tbThreshold_Scroll(object sender, EventArgs e)
        {
            lblThreshold.Text = tbThreshold.Value.ToString();
            if (picOriginalImg.Image != null) {
                picResultImg.Image = AddNoiseEffect(picOriginalImg.Image, tbThreshold.Value,  upNoise, downNoise);
            }            
        }

        public Image AddNoiseEffect(Image inputImg, int threshold, Color upNoiseColor, Color downNoiseColor)
        {
            Bitmap cloneImg = new Bitmap(inputImg);
            Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
            BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe
            {
                byte* ptrAddress = (byte*)bmpData.Scan0;
                for (int y = 0; y < bmpData.Height; y++)
                {
                    byte* currentAddress = ptrAddress + (y * bmpData.Stride);
                    for (int x = 0; x < bmpData.Stride; x+=3)
                    {
                        int averageColor = (currentAddress[x] + currentAddress[x + 1] + currentAddress[x + 2]) / 3;
                        currentAddress[x] = currentAddress[x + 1] = currentAddress[x + 2] = (byte)averageColor;
                        if ((averageColor % 100) < threshold) {
                            if ((averageColor % 2) == 0) {
                                currentAddress[x] = upNoiseColor.B;
                                currentAddress[x + 1] = upNoiseColor.G;
                                currentAddress[x + 2] = upNoiseColor.R;
                            } else {
                                currentAddress[x] = downNoiseColor.B;
                                currentAddress[x + 1] = downNoiseColor.G;
                                currentAddress[x + 2] = downNoiseColor.R;
                            }
                        }   
                    }
                }
            }
            cloneImg.UnlockBits(bmpData);
            return cloneImg;
        }
    }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Image Processing (Color Addition/Subtraction Algorithm)

Posted by ေတဇာလင္း Thursday, 9 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ Image တစ္ခုထဲသို႔ မိမိႏွစ္သက္ရာ Color တစ္ခုအား ေပါင္းထည့္၍ သို႔မဟုတ္ နဳတ္ယူ၍ ရုပ္လံုးေဖာ္ယူႏိုင္တာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ နည္းပညာ Term အရေတာ့ Color Addition/Subtraction Algorithm လို႔ေခၚပါတရ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Algorithm ရဲ႕ သေဘာတရားကေတာ့ အရမ္းကို ရိုးရွင္းပါတရ္။ Detect လုပ္မိတဲ့ RGB Color Value ေတြကို မိမိတို႔ ေရြးခ်ယ္ေပးလိုက္ေသာ Color ရဲ႕ RGB Color Value နဲ႔ ေပါင္းျခင္း/နဳတ္ျခင္းကို ျပဳလုပ္ပါတရ္။ ေနာက္ ရလာတဲ့ တန္ဖုိးကို မူလ Pixel ထဲသို႔ ျပန္လည္ Assign လုပ္လုိက္တာပဲျဖစ္ပါတရ္ဗ်။ ဥပမာအေနနဲ႔ေတာ့ က်ေနာ္ Color Addition/Subtraction Algorithm ကုိအသံုးျပဳၿပီး Color ေပါင္းျခင္း/နဳတ္ျခင္း ႏွစ္ခုစလံုးကို result ထုတ္ျပထားပါတရ္။ Screen Shoot ေတြကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔ နားလည္သြားၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်။ Algorithm ရဲ႕ လုပ္ငန္းစဥ္ေတြကေတာ့ ေအာက္ပါအတိုင္းပဲျဖစ္ပါတရ္ဗ်။

Algorithm:
1. Get the RGB value of the Detected pixel.
2. Calculate new RGB values as follows:
          newRGB = originalRBG + colorRGB;
  (OR)
          newRGB = originalRBG – colorRGB;
3. Replace the R, G and B value of the pixel with the values calculated in step 2.
4. Repeat Step 1 to Step 3 for each pixels of the image.

Example: 
 Detected Pixel = RGB(120, 80, 50);
 SpecifiedColor = RGB(10, 50, 45);
 Addition Color Processing => 
  newColor = DetectedColor + SpecifiedColor;
                newColor = RGB(120+10, 80+50, 50+45);  
  Pixel(RGB) = RGB(130, 130, 95);

Color Addition အတြက္ က်ေနာ္ Example မွာ pixel တစ္ခုစာ တြက္ျပထားပါတရ္။ အနည္းငယ္ ရွင္းျပရမရ္ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ယူပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ Detect ရရွိေသာ RGB တန္ဖိုးေတြကို Specified Color ရဲ႕ RBG Value နဲ႔ေပါင္းယူပါတရ္။ ေနာက္ဆံုးအဆင့္မွာေတာ့ ရရွိလာေသာ New Color တန္ဖိုး မူလ Pixel အတြင္းသို႔ ျပန္ Assign လုပ္ယူလိုက္တာပဲ ျဖစ္ပါတရ္။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး Addition/Subtraction Color Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။
မွတ္ခ်က္။ Color တစ္ခုရဲ႕ Range ဟာ 0 to 255 သာရွိလို႔ ၄င္း Range ထဲက လြတ္သြားလို႔ မရပါဘူး။ ဒါေၾကာင့္ Addition/Subtraction Processing မွာရရွိလာတဲ့ Color Value ဟာ သုည(0) ထက္ငယ္ေနရင္ 0 လို႔ယူၿပီး 255 ထက္ႀကီးသြားရင္ေတာ့ 255 လို႔ ယူရမရ္ဆိုတာကိုေတာ့ မေမ့ပါနဲ႔ဗ်။

ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ Substitution Color Algorithm ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ GUI ေဖာက္ Coding ေရးၿပီး လက္ေတြ႔ေလ့လာၾကည့္ရေအာင္။ ဒါကေတာ့ က်ေနာ္တို႔ Project မွာ အသံုးျပဳမရ္ Library File ေတြပါ။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(1)ခုနဲ႔ PictureBox(2)ခု၊ Panel(1) ခုနဲ႔ ComboBox(1)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။

        Color specifiedColor;
        private void pnColor_Click(object sender, EventArgs e)
        {
            specifiedColor = LoadColor();
            pnColor.BackColor = specifiedColor;

            cbColorMethod.SelectedIndex = -1;
        }

        public Color LoadColor()
        {
            ColorDialog colorD = new ColorDialog();
            Color returnColor = Color.Empty;
            if (colorD.ShowDialog() == DialogResult.OK) {
                returnColor = colorD.Color;
            }
            return returnColor;
        }

LoadColor()Method နဲ႔ Calling ပံုစံေတြကိုေတာ့ ေရွ႕သင္ခန္းစာမွာ ေလ့လာခဲ့ၿပီးျဖစ္လို႔ က်ေနာ္ မရွင္းျပေတာ့ပါဘူးဗ်။ အထက္ပါ Coding အားလံုးရဲ႕ ရည္ရြယ္ခ်က္ကေတာ့ Processing လုပ္မဲ့ Specified Color ကို ေရြးခ်ယ္ဖို႔ပါပဲဗ်ာ။ ခက္ခဲတာမပါလို႔ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Addition/Subtraction Color Image ေျပာင္းလဲယူမရ္႕ Method ကိုေတာ့ ComboBox ရဲ႕ SelectedIndexChanged_Event ထဲမွာေရးပါတရ္။ ဒါေၾကာင့္ ComboBox ရဲ႕ Index ေျပာင္းလဲမႈအေပၚမူတည္ၿပီး Image Result ေျပာင္းလဲမႈရွိပါလိမ့္မရ္ဗ်။

        public Image AddSubtractColor(Image inputImg, Color c, int colorMethod)
        {
            Bitmap cloneImg = new Bitmap(inputImg);
            Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
            BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe {
                byte* ptrAddress = (byte*)bmpData.Scan0;
                for (int y = 0; y < bmpData.Height; y++) {
                    byte* currentAddress = ptrAddress + (y * bmpData.Stride);
                    for (int x = 0; x < bmpData.Stride; x+=3) {
                        int rColor, gColor, bColor;
                        switch (colorMethod) {
                            case 0 : //For Add Color 
                                rColor = currentAddress[x + 2] + c.R;
                                rColor = (rColor < 0) ?  0 : (rColor > 255) ? 255 : rColor;
                                currentAddress[x + 2] = (byte)rColor;

                                gColor = currentAddress[x + 1] + c.G;
                                gColor = (gColor < 0) ? 0 : (gColor > 255) ? 255 : gColor;
                                currentAddress[x + 1] = (byte)gColor;

                                bColor = currentAddress[x] + c.B;
                                bColor = (bColor < 0) ? 0 : (bColor > 255) ? 255 : bColor;
                                currentAddress[x] = (byte)bColor;
                                break;
                            case 1: //For Subtract Color 
                                rColor = currentAddress[x + 2] - c.R;
                                rColor = (rColor < 0) ?  0 : (rColor > 255) ? 255 : rColor;
                                currentAddress[x + 2] = (byte)rColor;

                                gColor = currentAddress[x + 1] - c.G;
                                gColor = (gColor < 0) ? 0 : (gColor > 255) ? 255 : gColor;
                                currentAddress[x + 1] = (byte)gColor;

                                bColor = currentAddress[x] - c.B;
                                bColor = (bColor < 0) ? 0 : (bColor > 255) ? 255 : bColor;
                                currentAddress[x] = (byte)bColor;
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
            cloneImg.UnlockBits(bmpData);
            return cloneImg;
        }

Method ကိုေတာ့ Processing လုပ္မရ္႕ Image, Color Value နဲ႔ Processing Method တို႔ကို Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ Addition/Subtraction Color အလုပ္လုပ္သြားပံု အဆင့္ဆင့္ကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။ ComboxBox ရဲ႕ Index ႏွစ္ခုအတြက္ က်ေနာ္ Siwtch()statemet ကို အသံုးျပဳထားပါတရ္။ Index 0 က Addition Color အတြက္ျဖစ္ၿပီး Index 1 ကေတာ့ Subtraction Color အတြက္ျဖစ္ပါတရ္ဗ်။

Calling Method ေလးကို ဆက္ၾကည့္ၾကရေအာင္ဗ်ာ။

private void cbColorMethod_SelectedIndexChanged(object sender, EventArgs e)
{
     if (picOriginalImg.Image != null) {
         picResultImg.Image = AddSubtractColor(picOriginalImg.Image, specifiedColor, cbColorMethod.SelectedIndex);
     }            
}

ဒါကေေတာ့ ComboBox Index ေျပာင္းလဲအမႈအေပၚ မူတည္ၿပီး Color Processing Method ေျပာင္းလဲယူဖို႔အတြက္ Calling Method အေျခအေနပါ။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

namespace ImgProcessing
{
    public partial class frmAddSubtractColorImage : Form
    {
        public frmAddSubtractColorImage()
        {
            InitializeComponent();
        }

        private void btnLoadImage_Click(object sender, EventArgs e)
        {
            LoadImage(picOriginalImg);
        }

        public void LoadImage(PictureBox pic)
        {
            OpenFileDialog openFD = new OpenFileDialog();
            openFD.Title = "Load an Image";
            openFD.Filter = "JPEG Images|*.Jpg|PNG Images|*.Png|GIF Images|*.Gif|BITMAP Images|*.Bmp";
            if (openFD.ShowDialog() == DialogResult.OK) {
                pic.Image = Image.FromFile(openFD.FileName);
            }
        }

        Color specifiedColor;
        private void pnColor_Click(object sender, EventArgs e)
        {
            specifiedColor = LoadColor();
            pnColor.BackColor = specifiedColor;

            cbColorMethod.SelectedIndex = -1;
        }

        public Color LoadColor()
        {
            ColorDialog colorD = new ColorDialog();
            Color returnColor = Color.Empty;
            if (colorD.ShowDialog() == DialogResult.OK) {
                returnColor = colorD.Color;
            }
            return returnColor;
        }

        private void cbColorMethod_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (picOriginalImg.Image != null) {
                picResultImg.Image = AddSubtractColor(picOriginalImg.Image, specifiedColor, cbColorMethod.SelectedIndex);
            }            
        }

        public Image AddSubtractColor(Image inputImg, Color c, int colorMethod)
        {
            Bitmap cloneImg = new Bitmap(inputImg);
            Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
            BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe {
                byte* ptrAddress = (byte*)bmpData.Scan0;
                for (int y = 0; y < bmpData.Height; y++) {
                    byte* currentAddress = ptrAddress + (y * bmpData.Stride);
                    for (int x = 0; x < bmpData.Stride; x+=3) {
                        int rColor, gColor, bColor;
                        switch (colorMethod) {
                            case 0 : //For Add Color 
                                rColor = currentAddress[x + 2] + c.R;
                                rColor = (rColor < 0) ?  0 : (rColor > 255) ? 255 : rColor;
                                currentAddress[x + 2] = (byte)rColor;

                                gColor = currentAddress[x + 1] + c.G;
                                gColor = (gColor < 0) ? 0 : (gColor > 255) ? 255 : gColor;
                                currentAddress[x + 1] = (byte)gColor;

                                bColor = currentAddress[x] + c.B;
                                bColor = (bColor < 0) ? 0 : (bColor > 255) ? 255 : bColor;
                                currentAddress[x] = (byte)bColor;
                                break;
                            case 1: //For Subtract Color 
                                rColor = currentAddress[x + 2] - c.R;
                                rColor = (rColor < 0) ?  0 : (rColor > 255) ? 255 : rColor;
                                currentAddress[x + 2] = (byte)rColor;

                                gColor = currentAddress[x + 1] - c.G;
                                gColor = (gColor < 0) ? 0 : (gColor > 255) ? 255 : gColor;
                                currentAddress[x + 1] = (byte)gColor;

                                bColor = currentAddress[x] - c.B;
                                bColor = (bColor < 0) ? 0 : (bColor > 255) ? 255 : bColor;
                                currentAddress[x] = (byte)bColor;
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
            cloneImg.UnlockBits(bmpData);
            return cloneImg;
        }
    }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Image Processing (Color Substitution Algorithm)

Posted by ေတဇာလင္း Tuesday, 7 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ Image တစ္ခုရဲ႕ Color တစ္ခုအား မိမိႏွစ္သက္ရာ Color တစ္ခုနဲ႔ အစားထိုး ရုပ္လံုးေဖာ္ၾကည့္ႏိုင္တာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ နည္းပညာ Term အရေတာ့ Color Substitution Algorithm လို႔ေခၚပါတရ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Algorithm ရဲ႕ သေဘာတရားကေတာ့ က်ေနာ္တို႔ ေရွ႕မွာ ေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Black&White Algorithm and Bi-Tonal Algorithm တို႔နဲ႔ အတူတူပါပဲ။ ဒီေန႔ ေလ့က်င့္ခန္းမွာေတာ့ Algorithm ထဲသို႔ မိမိႀကိဳက္ႏွစ္သက္ရာ Color ႏွစ္ခုကို Passing လုပ္ၿပီး Processing လုပ္ခိုင္းမွာပါ။ ပထမ Color ကေတာ့ Source Color ျဖစ္ပါတရ္။ တနည္းအားျဖင့္ အစားထိုးျခင္းကို ခံရမရ္႕ Color Pixel ေပါ့။ ဒုတိယ Color ကေတာ့ Substituted Color သို႔မဟုတ္ ပထမ Color ေနရာမွာ ျပန္လည္အစားထိုးယူမရ္႕ Color ပဲျဖစ္ပါတရ္။ ေျပာင္းလဲယူတဲ့ေနရာမွာေတာ့ Threshold Value ေလးထားၿပီး Source Color နဲ႔ အနီးစပ္ဆံုး တူညီတဲ့ Pixel ေတြကိုပါ Substituted Color နဲ႔ အစားထိုးျပထားပါတရ္။ Color Value တိုင္းက Sensitive ျဖစ္လြန္းလို႔ Threshold Value ထားၿပီး အနီးစပ္ဆံုး တူညီတဲ့ Pixel ေတြကိုပါ ေျပာင္းလဲယူရတာလည္း ျဖစ္ပါတရ္။ ဥပမာအေနနဲ႔ေတာ့ က်ေနာ္ Color Substitution Algorithm ကုိအသံုးျပဳၿပီး လုပ္ငန္းစဥ္တစ္ခုမွာ ေမာ္ဒယ္ရဲ႕ အက်ီၤ Color ကို ခ်ိန္းျပထားပါတရ္။ ေနာက္တစ္ခုမွာေတာ့ Background Color ကို ခ်ိန္းျပထားပါတရ္ဗ်။ Screen Shoot ေတြကို ၾကည့္လိုက္ရင္ေတာ့ မိတ္ေဆြတို႔ ဆိုလိုရင္းကို နားလည္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္။ Algorithm ရဲ႕ လုပ္ငန္းစဥ္ေတြကေတာ့ ေအာက္ပါအတိုင္းပဲျဖစ္ပါတရ္ဗ်။

Algorithm:
1. Get the RGB value of the Detected pixel.
2. Calculate the total value of Source Color:
        totalSourceColor = SourceR + SourceG + SourceB;
3. Calculate the total value of Detected Pixel Color:
        totalPixelColor = originalR + originalG + originalB;
4. Calculate new RGB values as follows:
        If ((totalSourceColor – totalPixelColor) < Thershold) Then
           newRGB = RGB of substitution Color;
 Else
    newRGB = RGB of Detected Color(oldColor);
5. Replace the R, G and B value of the pixel with the values calculated in step 4.
6. Repeat Step 1 to Step 5 for each pixels of the image.

Example: 
 Dtetected Pixel = RGB(120, 80, 50);
 SourceColor = RGB(110, 50, 45);
 SubstitutionColor = RGB(55, 20, 100);
 Substitution Color Processing => 
           Threshold = 70; 
           totalSourceColor = 110+55+45; = 210;
           totalPixelColor = 120+80+5; = 205;
           If((210 - 205) < 70)
             Pixel(RGB) = RGB(55, 20, 100);

အနည္းငယ္ ရွင္းျပရမရ္ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ၿပီး စုစုေပါင္း totalPixelColor တန္ဖိုးကို ရွာပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ Source Color ရဲ႕ RGB တန္ဖိုးေတြကိုေပါင္းၿပီး totalSourceColor တန္ဖိုးကိုရွာပါတရ္။ ေနာက္တဆင့္မွာေတာ့ TotalSourceColor နဲ႔ totalPixelColor တို႔ရဲ႕ ျခားနားျခင္းကိုရွာၿပီး Threshold Value နဲ႔ ႏႈိင္းယွဥ္ပါတရ္။ Threshold တန္ဖိုးက ႀကီးခဲ့ရင္ေတာ့ ၄င္း Pixel ကို Substitution Color နဲ႔ အစားထိုးလိုက္မွာျဖစ္ၿပီး Threshold ငယ္ေနမရ္ဆိုရင္ေတာ့ ၄င္း Pxiel ကို မူလအတိုင္းျပန္ Assign လုပ္ယူလိုက္တာပဲ ျဖစ္ပါတရ္။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး BiTonal Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။ ဥပမာအေနနဲ႔ေတာ့ က်ေနာ္ Pixel တစ္ခုစာ တြက္ျပထားပါတရ္။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(1)ခုနဲ႔ PictureBox(2)ခု၊ Panel(2)ခု၊ TrackBar(1)ခုနဲ႔ Label(1)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။

က်ေနာ္တို႔ Processing လုပ္မရ္႕ Color ႏွစ္ခုအတြက္ Panel Box ႏွစ္ခုကို သံုးထားပါတရ္။ Panel Box ရဲ႕ Click_Event ေတြမွာ ColorDialog Box ေတြကိုေခၚၿပီး မိမိႏွစ္သက္ရာ Color ကိုေရြးခ်ယ္မွာျဖစ္ပါတရ္။ ဒါေပမဲ့ ဒီေလ့က်င့္ခန္းမွာေတာ့ တမူထူးျခားသြားေအာင္ Source Color ေရြးခ်ယ္တဲ့ေနရာမွာ MouseDown_Event ကိုထည့္သံုးျပထားပါတရ္။ Picture ေပၚသို႔ Mouse Down လုပ္လုိက္တဲ့ Coordinate မွာရွိတဲ့ Pixel ရဲ႕ Color Value ကို Source Color အျဖစ္ရယူလိုက္တာပါ။ မိတ္ေဆြတို႔အေနနဲ႔ ColorDialog ပံုစံျဖင့္ျဖစ္ေစ၊ MouseDown ပံုစံျဖင့္ျဖစ္ေစ Source Color ကိုရယူႏိုင္ပါတရ္။ က်ေနာ္ကေတာ့ Color Loading နည္းလမ္းႏွစ္ခုအတြက္ Method ခြဲေရးထားပါတရ္။ ေအာက္မွာ ေလ့လာၾကည့္လုိက္ပါဗ်ာ။

Color sourceColor, subColor;
private void picOriginalImg_MouseDown(object sender, MouseEventArgs e)
{
   Bitmap cloneImg = new Bitmap(picOriginalImg.Width, picOriginalImg.Height);
   Rectangle rect = new Rectangle(0, 0, picOriginalImg.Width, picOriginalImg.Height);
   if (rect.Contains(e.Location)) {
      using (Graphics gfx = Graphics.FromImage(cloneImg)) {
          gfx.DrawImage(picOriginalImg.Image, rect);
          sourceColor = cloneImg.GetPixel(e.X, e.Y);
          pnSourceColor.BackColor = sourceColor;
      }
   }
}

private void pnSourceColor_Click(object sender, EventArgs e)
{
    sourceColor = LoadColor();
    pnSourceColor.BackColor = sourceColor;
}

private void pnSubColor_Click(object sender, EventArgs e)
{
    subColor = LoadColor();
    pnSubColor.BackColor = subColor;
}

public Color LoadColor()
{
    ColorDialog colorD = new ColorDialog();
    Color returnColor = Color.Empty;
    if (colorD.ShowDialog() == DialogResult.OK) {
         returnColor = colorD.Color;
    }
    return returnColor;
}

ပထမ picOriginalImg_MouseDown() Method ကေတာ့ Image ရဲ႕ မိမိေျပာင္းလဲေစခ်င္ေသာ Color ကုိေရြးခ်ယ္တဲ့ ေနရာမွာ Mouse Down ကိုအသုံးျပဳၿပီး PictureBox ထဲမွာ မိမိႏွစ္သက္ရာ Source Color ကို ေရြးခ်ယ္ဖို႔ပဲျဖစ္ပါတရ္။ Grahpic Library ကိုအသံုးျပဳထားပါတရ္။ ေနာက္ Mouse Down လုပ္လိုက္ေသာ Picture ေပၚမွ x, y coordinate ရဲ႕ Color Value ကိုဆြဲထုတ္ၿပီး Global ေၾကျငာခဲ့ေသာ sourceColor ထဲသို႔ သြား Assign လုပ္ထားလိုက္တာပဲျဖစ္ပါတရ္။ ေအာက္က LoadColor()Method နဲ႔ Calling ပံုစံေတြကိုေတာ့ ေရွ႕သင္ခန္းစာမွာ ေလ့လာခဲ့ၿပီးျဖစ္လို႔ က်ေနာ္ မရွင္းျပေတာ့ပါဘူးဗ်။ အထက္ပါ Coding အားလံုးရဲ႕ ရည္ရြယ္ခ်က္ကေတာ့ Source Color နဲ႔ Substitution Color ကို ေရြးခ်ယ္ဖို႔ပါပဲဗ်ာ။ ခက္ခဲတာမပါလို႔ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Substitution Color Image ေျပာင္းလဲယူမရ္႕ Method ကိုေတာ့ TrackBar ရဲ႕ Scroll_Event ထဲမွာေရးပါတရ္။ ဒါေၾကာင့္ TrackBar Value ေျပာင္းလဲမႈရွိတိုင္း Image Result ေျပာင္းလဲမႈရွိပါလိမ့္မရ္ဗ်။

public Image ChangeColor(Image inputImg,int threshold, Color sColor, Color dColor)
{
   Bitmap cloneImg = new Bitmap(inputImg);
   Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
   BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
   unsafe {
      byte* ptrAddress = (byte*)bmpData.Scan0;
      for (int y = 0; y < bmpData.Height; y++) {
         byte* currentAddress = ptrAddress + (y * bmpData.Stride);
         for (int x = 0; x < bmpData.Stride; x = x + 3) {
            int SrcTotalRGB = sColor.R + sColor.G + sColor.B;
            int TotalRGB = currentAddress[x] + currentAddress[x+1] + currentAddress[x+2];
            if (Math.Abs(SrcTotalRGB - TotalRGB) < threshold) {
               currentAddress[x + 2] = dColor.R;
               currentAddress[x + 1] = dColor.G;
               currentAddress[x] = dColor.B;
            }
          }
       }
       cloneImg.UnlockBits(bmpData);
       return cloneImg;
    }
}

Method ကိုေတာ့ Processing လုပ္မရ္႕ Image, Threshold Value နဲ႔ Color Value ႏွစ္ခုကုိ Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ Substitution Color အစားထိုး အလုပ္လုပ္သြားပံုအဆင့္ဆင့္ကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။

Calling Method ေလးကို ဆက္ၾကည့္ၾကရေအာင္ဗ်ာ။

private void tbThresholdValue_Scroll(object sender, EventArgs e)
{
   if (picOriginalImg.Image != null) {
      picResultImg.Image = ChangeColor(picOriginalImg.Image, tbThresholdValue.Value, sourceColor, subColor);
      lblThresholdValue.Text = tbThresholdValue.Value.ToString();
   }  
}

ဒါကေေတာ့ TrackBar သို႔မဟုတ္ Threshold Value ရဲ႕ ေျပာင္းလဲအမႈအေပၚ မူတည္ၿပီး Substitution Color Image ေျပာင္းလဲယူဖို႔အတြက္ Calling Method အေျခအေနပါ။ ေျပာင္းလဲသြားတဲ့ Threshold Value ကိုေတာ့ label နဲ႔ Infornation ထုတ္ျပထားပါတရ္။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။

using System;
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

namespace ImgProcessing
{
    public partial class frmColorSubstitutionImage : Form
    {
        public frmColorSubstitutionImage()
        {
            InitializeComponent();
        }

        private void btnLoadImage_Click(object sender, EventArgs e)
        {
            LoadImage(picOriginalImg);
        }

        public void LoadImage(PictureBox pic)
        {
            OpenFileDialog openFD = new OpenFileDialog();
            openFD.Title = "Load an Image";
            openFD.Filter = "JPEG Images|*.Jpg|PNG Images|*.Png|GIF Images|*.Gif|BITMAP Images|*.Bmp";
            if (openFD.ShowDialog() == DialogResult.OK) {
                pic.Image = Image.FromFile(openFD.FileName);
            }
        }

        Color sourceColor, subColor;
        private void picOriginalImg_MouseDown(object sender, MouseEventArgs e)
        {
            Bitmap cloneImg = new Bitmap(picOriginalImg.Width, picOriginalImg.Height);
            Rectangle rect = new Rectangle(0, 0, picOriginalImg.Width, picOriginalImg.Height);
            if (rect.Contains(e.Location)) {
                using (Graphics gfx = Graphics.FromImage(cloneImg)) {
                    gfx.DrawImage(picOriginalImg.Image, rect);
                    sourceColor = cloneImg.GetPixel(e.X, e.Y);
                    pnSourceColor.BackColor = sourceColor;
                }
            }
        }

        private void pnSourceColor_Click(object sender, EventArgs e)
        {
            sourceColor = LoadColor();
            pnSourceColor.BackColor = sourceColor;
        }

        private void pnSubColor_Click(object sender, EventArgs e)
        {
            subColor = LoadColor();
            pnSubColor.BackColor = subColor;
        }

        public Color LoadColor()
        {
            ColorDialog colorD = new ColorDialog();
            Color returnColor = Color.Empty;
            if (colorD.ShowDialog() == DialogResult.OK) {
                returnColor = colorD.Color;
            }
            return returnColor;
        }

        private void tbThresholdValue_Scroll(object sender, EventArgs e)
        {
            if (picOriginalImg.Image != null) {
                picResultImg.Image = ChangeColor(picOriginalImg.Image, tbThresholdValue.Value, sourceColor, subColor);
                lblThresholdValue.Text = tbThresholdValue.Value.ToString();
            }  
        }

        public Image ChangeColor(Image inputImg,int threshold, Color sColor, Color dColor)
        {
            Bitmap cloneImg = new Bitmap(inputImg);
            Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
            BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe {
                byte* ptrAddress = (byte*)bmpData.Scan0;
                for (int y = 0; y < bmpData.Height; y++) {
                    byte* currentAddress = ptrAddress + (y * bmpData.Stride);
                    for (int x = 0; x < bmpData.Stride; x = x + 3) {
                        int SrcTotalRGB = sColor.R + sColor.G + sColor.B;
                        int TotalRGB = currentAddress[x] + currentAddress[x+1] + currentAddress[x+2];
                        if (Math.Abs(SrcTotalRGB - TotalRGB) < threshold) {
                            currentAddress[x + 2] = dColor.R;
                            currentAddress[x + 1] = dColor.G;
                            currentAddress[x] = dColor.B;
                        }
                    }
                }
                cloneImg.UnlockBits(bmpData);
                return cloneImg;
            }
        }
    }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Image Processing (Bi-Tonal Color Algorithm)

Posted by ေတဇာလင္း 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ Image တစ္ခုအား မိမိႏွစ္သက္ရာ Color ႏွစ္ခုတည္းျဖင့္ ဘရ္လို ရုပ္လံုးေဖာ္ၾကည့္ႏိုင္မလဲ ဆိုတာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ နည္းပညာ Term အရေတာ့ BiTonal Color Algorithm လို႔ေခၚပါတရ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Algorithm ရဲ႕ သေဘာတရားကေတာ့ က်ေနာ္တို႔ ေရွ႕မွာ ေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Binary Color သို႔မဟုတ္ Black&White Algorithm နဲ႔ အတူတူပါပဲ။ ေလ့လာခဲ့ၿပီးသား မိတ္ေဆြတို႔အေနနဲ႔ ဒီေန႔ ေလ့က်င့္ခန္းက အရမ္းကို လြယ္ကူေနပါလိမ့္မရ္။ Black&White တုန္းက 1 and 0 သို႔မဟုတ္ Color ရဲ႕ Lower bound and Upper bound ႏွစ္ခုတည္းမွာပဲ အလုပ္လုပ္ပါတရ္။ ဒီေန႔ ေလ့က်င့္ခန္းမွာေတာ့ Algorithm ထဲသို႔ မိမိႀကိဳက္ႏွစ္သက္ရာ Color ႏွစ္ခုကို Passing လုပ္ၿပီး Processing လုပ္ႏိုင္မွာျဖစ္ပါတရ္။ Color ႏွစ္ခုျဖစ္တဲ့အတြက္ Threshold Value တစ္ခုနဲ႔ ပိုင္းျခားၿပီး ရုပ္လံုးေဖာ္မွာပါ။ Algorithm ရဲ႕ လုပ္ငန္းစဥ္ေတြကေတာ့ ေအာက္ပါအတိုင္းပဲျဖစ္ပါတရ္ဗ်။

Algorithm:
1. Get the RGB value of the pixel.
2. Calculate Average of RGB(Average=(R+G+B)/3).
3. Calculate new RGB values as follows:
        If Average >= Thershold Then
                RGB = Color1
 Else
  RGB = Color2
4. Replace the R, G and B value of the pixel with the values calculated in step 3.
5. Repeat Step 1 to Step 4 for each pixels of the image.

Example: 
 Pixel = RGB(120, 80, 200);
 BiTonal Processing => 
        Threshold = 20; Color1 = gold; Color2=orange;
  Average = (120+80+200)/3; = 133;
  If(Average >= Threshold)
   Pixel(RGB) = gold;

အနည္းငယ္ ရွင္းျပရမရ္ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ ရလာတဲ့ RGB Color Value ေတြကို Average ရွာၿပီး Threshold Value နဲ႔ ႏႈိင္းယွဥ္ပါတရ္။ Average တန္ဖိုးက ႀကီးခဲ့ရင္ေတာ့ ၄င္း Pixel ကို Color1 နဲ႔ Assign လုပ္ပါတရ္။ Threshold ကႀကီးေနမရ္ဆိုရင္ေတာ့ ၄င္း Pxiel ကို Color2 နဲ႔ Assign လုပ္ယူလိုက္တာပဲျဖစ္ပါတရ္။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး BiTonal Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။ ဥပမာအေနနဲ႔ေတာ့ က်ေနာ္ Pixel တစ္ခုစာ တြက္ျပထားပါတရ္။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ BiTonal Algorithm ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ GUI ေဖာက္ Coding ေရးၿပီး လက္ေတြ႔ေလ့လာၾကည့္ရေအာင္။ ဒါကေတာ့ က်ေနာ္တို႔ Project မွာ အသံုးျပဳမရ္ Library File ေတြပါ။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

က်ေနာ္တို႔ ရုပ္လံုးေဖာ္မည့္ Color ႏွစ္ခုကိုဆြဲတင္ဖို႔အတြက္ေတာ့ Panel Box ႏွစ္ခုကို သံုးထားပါတရ္။ Panel Box ရဲ႕ Click_Event ေတြမွာ ColorDialog Box ေတြကိုေခၚၿပီး မိမိႏွစ္သက္ရာ Color ကိုေရြးခ်ယ္မွာျဖစ္ပါတရ္။ က်ေနာ္ကေတာ့ Color Loading အတြက္ Method ခြဲေရးထားပါတရ္။ ေအာက္မွာ ေလ့လာၾကည့္လုိက္ပါဗ်ာ။

       Color firstColor, secondColor;
       private void pnColor1_Click(object sender, EventArgs e)
       {
           firstColor = LoadColor();
           pnColor1.BackColor = firstColor;
       }

       private void pnColor2_Click(object sender, EventArgs e)
       {
           secondColor = LoadColor();
           pnColor2.BackColor = secondColor;
       }

       public Color LoadColor()
       {
           ColorDialog colorD = new ColorDialog();
           Color returnColor = Color.Empty;
           if (colorD.ShowDialog() == DialogResult.OK) {
               returnColor = colorD.Color;
           }
           return returnColor;
       }

က်ေနာ္တို႔ စစခ်င္းမွာ Global အေနနဲ႔ Coloar Variable ႏွစ္ခုကိုေၾကျငာထားပါတရ္။ က်ေနာ္တို႔ ဆြဲတင္ယူမရ္႕ Color ႏွစ္ခုကို ၄င္း Variable ႏွစ္ခုနဲ႔ Assign လုပ္ၿပီး Algorithm ကို Passing လုပ္မွာျဖစ္ပါတရ္။ LoadColor()Method က ရိုးရွင္းပါတရ္။ ColorDialog Box ကိုေခၚၿပီး ေရြးခ်ယ္လိုက္တဲ့ Color ကို Calling Mehtod သို႔ Return ျပန္ေပးယံုပါပဲ။ Calling Method အေနနဲ႔ေတာ့ Panel ႏွစ္ခုရဲ႕ Click_Event ေတြက ေခၚထားပါတရ္။ ဒါအျပင္ ဘရ္လို Color ေတြကို ေရြးခ်ယ္လုိက္တရ္ဆိုတာကို User အေနနဲ႔ ျမင္ေတြ႔ႏိုင္ဖို႔အတြက္ Panel ေတြရဲ႕ Background Color ေတြအျဖစ္ ျပန္ဆြဲတင္ ျပထားပါေသးတရ္ဗ်။ ခက္ခဲတာမပါလို႔ နားလည္လိမ့္မရ္လို႔ ယံုၾကည္ပါတရ္ဗ်။

BiTonal Image ေျပာင္းလဲယူမရ္႕ Method ကိုေတာ့ TrackBar ရဲ႕ Scroll_Event ထဲမွာေရးပါတရ္။ ဒါေၾကာင့္ TrackBar Value ေျပာင္းလဲမႈရွိတိုင္း Image Result ေျပာင္းလဲမႈရွိပါလိမ့္မရ္ဗ်။

public Image CustomBiTonalColor(Image inputImg, int threshold, Color color1, Color color2)
{
           Bitmap cloneImg = new Bitmap(inputImg);
           Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
           BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
           unsafe {
               byte* firstAddress = (byte*)bmpData.Scan0;
               for (int y = 0; y < bmpData.Height; y++) {
                   byte* currentAddress = firstAddress + (y * bmpData.Stride);
                   for (int x = 0; x < bmpData.Stride; x = x + 3) {
                       int averageColor = (currentAddress[x] + currentAddress[x + 1] + currentAddress[x + 2]) / 3;
                       if (averageColor >= threshold) {
                           currentAddress[x] = color1.B;
                           currentAddress[x + 1] = color1.G;
                           currentAddress[x + 2] = color1.R;
                       } else {
                           currentAddress[x] = color2.B;
                           currentAddress[x + 1] = color2.G;
                           currentAddress[x + 2] = color2.R;
                       }
                   }
               }
               cloneImg.UnlockBits(bmpData);
               return cloneImg;
           }
}

Method ကိုေတာ့ Processing လုပ္မရ္႕ Image, Threshold Value နဲ႔ Color Value ႏွစ္ခုကုိ Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ BiTonal Color ခြဲၿပီး Assign လုပ္သြားပံုအဆင့္ဆင့္ကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။ Calling Method ေလးကို ဆက္ၾကည့္ၾကရေအာင္ဗ်ာ။

private void tbThresholdValue_Scroll(object sender, EventArgs e)
{
     lblThresholdValue.Text = tbThresholdValue.Value.ToString();
     if (picOriginalImg.Image != null) {
        picResultImg.Image = CustomBiTonalColor(picOriginalImg.Image, tbThresholdValue.Value, firstColor, secondColor);
     }        
}

ဒါကေေတာ့ TrackBar သို႔မဟုတ္ Threshold Value ရဲ႕ ေျပာင္းလဲအမႈအေပၚ မူတည္ၿပီး BiTonal Image ေျပာင္းလဲယူဖို႔အတြက္ Calling Method အေျခအေနပါ။ ေျပာင္းလဲသြားတဲ့ Threshold Value ကိုေတာ့ label နဲ႔ Infornation ထုတ္ျပထားပါတရ္။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;
namespace ImgProcessing
{
   public partial class frmCustomBiTonalColor : Form
   {
       public frmCustomBiTonalColor()
       {
           InitializeComponent();
       }

       private void btnLoadImage_Click(object sender, EventArgs e)
       {
           LoadImage(picOriginalImg);
       }

       public void LoadImage(PictureBox pic)
       {
           OpenFileDialog openFD = new OpenFileDialog();
           openFD.Title = "Load an Image";
           openFD.Filter = "JPEG Images|*.Jpg|PNG Images|*.Png|GIF Images|*.Gif|BITMAP Images|*.Bmp";
           if (openFD.ShowDialog() == DialogResult.OK) {
               pic.Image = Image.FromFile(openFD.FileName);
           }
       }

       Color firstColor, secondColor;
       private void pnColor1_Click(object sender, EventArgs e)
       {
           firstColor = LoadColor();
           pnColor1.BackColor = firstColor;
       }

       private void pnColor2_Click(object sender, EventArgs e)
       {
           secondColor = LoadColor();
           pnColor2.BackColor = secondColor;
       }

       public Color LoadColor()
       {
           ColorDialog colorD = new ColorDialog();
           Color returnColor = Color.Empty;
           if (colorD.ShowDialog() == DialogResult.OK) {
               returnColor = colorD.Color;
           }
           return returnColor;
       }

       private void tbThresholdValue_Scroll(object sender, EventArgs e)
       {
           lblThresholdValue.Text = tbThresholdValue.Value.ToString();
           if (picOriginalImg.Image != null) {
               picResultImg.Image = CustomBiTonalColor(picOriginalImg.Image, tbThresholdValue.Value, firstColor, secondColor);
           }        
       }

       public Image CustomBiTonalColor(Image inputImg, int threshold, Color color1, Color color2)
       {
           Bitmap cloneImg = new Bitmap(inputImg);
           Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
           BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
           unsafe {
               byte* firstAddress = (byte*)bmpData.Scan0;
               for (int y = 0; y < bmpData.Height; y++) {
                   byte* currentAddress = firstAddress + (y * bmpData.Stride);
                   for (int x = 0; x < bmpData.Stride; x = x + 3) {
                       int averageColor = (currentAddress[x] + currentAddress[x + 1] + currentAddress[x + 2]) / 3;
                       if (averageColor >= threshold) {
                           currentAddress[x] = color1.B;
                           currentAddress[x + 1] = color1.G;
                           currentAddress[x + 2] = color1.R;
                       } else {
                           currentAddress[x] = color2.B;
                           currentAddress[x + 1] = color2.G;
                           currentAddress[x + 2] = color2.R;
                       }
                   }
               }
               cloneImg.UnlockBits(bmpData);
               return cloneImg;
           }
       }        
   }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Image Processing (Contrast Algorithm)

Posted by ေတဇာလင္း Friday, 3 March 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ Image တစ္ခုကို Contrast Algorithm ကိုအသံုးျပဳၿပီးေတာ့ Color ေတြကို Control လုပ္ႏိုင္တာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

Contrast Algorithm ရဲ႕ အလုပ္လုပ္ပံုကေတာ့ Pixel တစ္ခုကို Detect လုပ္မရ္။ Detect လုပ္ၿပီးတဲ့အခါမွာေတာ့ bright ျဖစ္တဲ့ Pixel ျဖစ္ရင္ RGB Value ေတြကို သတ္မွတ္ေပးလိုက္တဲ့ Contrast အတိုင္းတိုးေပးလိုက္မွာျဖစ္ၿပီး dark ျဖစ္တဲ့ Pixel ျဖစ္ခဲ့ရင္ေတာ့ သတ္မွတ္ေပးလိုက္တဲ့ Contrast အတိုင္း RGB Value ေတြကို ေလွ်ာ့ခ်ေပးပါလိမ့္မရ္။ တနည္းေျပာ ရရင္ Contrast ဆိုတာ Image တစ္ခုရဲ႕ Brithtest and Drakest Area အၾကား ဘရ္ေလာက္အေနအထား(length)အထိ ျခားနားေပးလိုက္မရ္ ဆိုတာကို သတ္မွတ္ေပးတာပါ။ Contrast Increase ျဖစ္ရင္ (သို႔မဟုတ္) ျခားနားခ်က္မ်ားလာရင္ Vibrant မ်ားၿပီး အေရာင္အေသြး ေတာက္လာမွာျဖစ္ၿပီး Contrast Decrease ျဖစ္လာရင္ေတာ့ အေရာင္အေသြး ထိုင္းမိႈင္းတဲ့ဘက္ကို ကူးသြားမွာျဖစ္ပါတရ္။ Fig ေတြမွာ ၾကည့္လိုက္ရင္ေတာ့ ဆိုလိုရင္းကို နားလည္ၾကလိမ့္မရ္လို႔ ထင္ပါတရ္ဗ်။

Contrast တန္ဖိုး သတ္မွတ္တဲ့အခါမွာေတာ့ Threshold Value အေနနဲ႔ -100 to 100 ၾကားကို သတ္မွတ္ေပး ႏိုင္ပါတရ္။ Positive Values ကေတာ့ Image ရဲ႕ Contrast တန္ဖိုးကို တိုးေပးမွာျဖစ္ၿပီး Negative Values ေတြကေတာ့ Image ရဲ႕ Contrast တန္ဖိုးကို ေလွ်ာ့ခ်ေပးမွာျဖစ္ပါတရ္။ Contrast တန္ဖိုး သုည(0) ကေတာ့ Contrast အလုပ္ မလုပ္ရေသးတဲ့အေျခအေန (သို႔မဟုတ္) Image ရဲ႕ မူလအေျခအေနပဲျဖစ္ပါတရ္။ ဒါေပမဲ့ Algorithm ထဲေရာက္တဲ့ အခါမွာေတာ့ Contrast တြက္ယူတဲ့ Formula ကိုျဖတ္ရပါတရ္။ ဒီအခ်ိန္မွာေတာ့ Contrast တန္ဖိုးဟာ 0 to 4 ၾကားသာ အလုပ္ လုပ္တာကို ေတြ႔ရပါလိမ့္မရ္။ က်ေနာ္တို႔ ေရြးခ်ယ္ေပးလိုက္တဲ့ -100 to 100 ၾကား Threshold Value ကို Contrast Value အျဖစ္ ေျပာင္းလဲေပးတဲ့ Formula ကေတာ့...

Contrast = Math.Pow(((100.0 + Threshold) / 100.0), 2);

အခုလိုပုံစံျဖစ္ပါတရ္။ တကယ္အသံုးျပဳမရ္႕ Contrast တန္ဖိုး တြက္ထုတ္ၿပီးတဲ့အခ်ိန္မွာေတာ့ Contrast = 1 ဟာ ေျပာင္းလဲမႈမရွိတဲ့ မူလ Image အေျခအေနျဖစ္ၿပီး 0 to 1 ၾကားကေတာ့ Contrast Decrease ဘက္ကို ကစားႏိုင္မရ္႕ အေျခအေနပါ။ ဒီလိုပါပဲ 1 to 4 ၾကားကေတာ့ Contrast Increase ဘက္ကို စကားႏိုင္မရ္႕ အေျခအေနပဲျဖစ္ပါတရ္။ Contrast တန္ဖိုးကို သိၿပီဆိုရင္ေတာ့ က်ေနာ္တို႔ Algorithm လုပ္ငန္းစဥ္ေလးကို ေလ့လာၾကည့္ပါ့မရ္။

Algorithm:
1. Get the RGB value of the pixel.
2. Calculate new RGB values as follows:
        R = ((((originalR / 255.0) – 0.5) * Contrast) + 0.5) * 255.0;
        G = ((((originalG / 255.0) – 0.5) * Contrast) + 0.5) * 255.0;
        B = ((((originalB / 255.0) – 0.5) * Contrast) + 0.5) * 255.0;
3.   Replace the R, G and B value of the pixel with the values calculated in step 2.
4. Repeat Step 1 to Step 3 for each pixels of the image.

Example: For Red,
 Pixel = RGB(120, 80, 200);
 Contrast Processing => Contrast = 2;
  Red = ((((120 / 255.0) – 0.5) * 2) + 0.5) * 255.0;
       = ((( 0.47 – 0.5) * 2) + 0.5) * 255.0;
       = (( -0.029 * 2) + 0.5) * 255.0;
       = (-0.058 + 0.5) * 255.0;
       = 0.44 * 255.0;
       = 112.5;

အနည္းငယ္ ရွင္းျပရမရ္ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ ရလာတဲ့ RGB Color Value ေတြကို Contrast Formula ထဲကိုျဖတ္ၿပီး RGB Color Value အသစ္ေတြကို ဖန္တီးယူပါတရ္။ Contrast Formula ပံုစံကေတာ့ RGB = ((((originalRGB / 255.0) – 0.5) * Contrast) + 0.5) * 255.0; အခုလိုျဖစ္ပါတရ္။ တတိယအဆင့္မွာေတာ့ ရရွိလာတဲ့ Color Value အသစ္ေတြကို မူလ Pixel ရဲ႕ RGB Color Value ေနရာေတြမွာ ျပန္အစားထိုးလိုက္တာပါ။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး Contrast Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။ ဥပမာအေနနဲ႔ေတာ့ က်ေနာ္ Red Color တစ္ခုကို Contrast တြက္ျပထားပါတရ္။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ Contrast Algorithm ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ GUI ေဖာက္ Coding ေရးၿပီး လက္ေတြ႔ေလ့လာၾကည့္ရေအာင္။ ဒါကေတာ့ က်ေနာ္တို႔ Project မွာ အသံုးျပဳမရ္ Library File ေတြပါ။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(1)ခုနဲ႔ PictureBox(2)ခု၊ TrackBar(1)ခုနဲ႔ Label(1)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။

TrackBar ကို Initial Value = 100 ေပးထားတာကေတာ့ Contrast In/Out အတြက္ TrackBar ကို စမွတ္ 100 မွာ Zero Line ခ်လိုက္တာပါ။ ဒါမွ ကနဦး ဆြဲတင္လိုက္ေသာ Image ဟာ 100(0%)မွာ ေဖာ္ျပၿပီး 100 ေအာက္ငယ္သြားရင္ Contrast Decrease Proces ဘက္ကုိလုပ္္ကာ 100 ထက္မ်ားသြားရင္ေတာ့ Contrast Increase Process ဘက္ကိုလုပ္ပါလို႔ ခိုင္းလို႔ရမွာပါ။ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္။ ဒီေတာ့ TrackBar ရဲ႕ Value အခ်ိန္းအေျပာင္းေပၚမူတည္ၿပီး Brightness Result ေျပာင္းလဲ လုပ္ေဆာင္သြားမွာျဖစ္ပါတရ္။ TrackBar ကို D-Click ေပးၿပီး ေအာက္က Method ေလးကို ေရးယူလိုက္ပါဗ်ာ။

public Image SimpleContrastImage(Image inputImg, int threshold)
{
   Bitmap cloneImg = new Bitmap(inputImg);
   Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
   BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
   Unsafe {
      byte* ptrAddress = (byte*)bmpData.Scan0;
      double contrast = Math.Pow((100.0 + threshold) / 100.0, 2);
      int totalByte = bmpData.Height * bmpData.Stride;
      for (int i = 0; i < totalByte; i++) {
         double fContrast = ((((ptrAddress[i] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
         fContrast = (fContrast < 0) ? 0 : (fContrast > 255) ? 255 : fContrast;
             ptrAddress[i] = (byte)fContrast;
      }
  }
  cloneImg.UnlockBits(bmpData);
  return cloneImg;
}

Method ကိုေတာ့ Processing လုပ္မရ္႕ Image နဲ႔ Contrast Changing အတြက္ Threshold Value ကုိ Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ R, G, B Contrast Value အတိုး/အေလွ်ာ့ လုပ္သြားတဲ့ပုံကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။ ဒီေလ့က်င့္ခန္းမွာေတာ့ တမူထူးျခားသြားေအာင္ Coding ေရးသားတဲ့ ပံုစံေလးကို အနည္းငရ္ ခ်ိန္းထားပါတရ္။ R, G, B Color တန္ဖိုး အခ်ိန္းအေျပာင္း အားလံုးဟာ တူညီတဲ့ Formula တစ္ခုတည္းမွာ အလုပ္လုပ္တာပါ။ ဒီေတာ့ Image တစ္ခုလံုးမွာရွိတဲ့ Byte အေရအတြက္ကို အရင္ရွာၿပီး For loop နဲ႔ တစ္ေၾကာင္းတည္းပတ္ကာ အလုပ္ လုပ္ခိုင္းထားပါတရ္။ ေရွ႕သင္ခန္းစာေတြမွာ ေလ့လာခဲ့တဲ့ R, G, B Color တန္ဖိုး တစ္ခုခ်င္းစီ ခြဲတြက္ယူတာနဲ႔ အတူတူပါပဲ။ ဒီေန႔ ေလ့လာတဲ့ ပံုစံက Coding နည္းတရ္ဆိုေပမဲ့ Processing Time အနည္းငရ္ ပိုေႏွးတရ္္ဆိုတာေတာ့ သိထားေစခ်င္ပါတရ္။ အရင္ပံုစံအတိုင္း သံုးခ်င္တဲ့ မိတ္ေဆြတို႔ အေနနဲ႔ေတာ့ ေအာက္က Coding အတိုင္း Method မွာ အစားထိုး အသံုးျပဳႏိုင္ပါတရ္။

unsafe {
  byte* ptrAddress = (byte*)bmpData.Scan0;
  double contrast = Math.Pow((100.0 + threshold) / 100.0, 2);
  for (int y = 0; y < bmpData.Height; y++) {
     byte* currentAddress = ptrAddress + (y * bmpData.Stride);
     for (int x = 0; x < bmpData.Stride; x += 3) {
       double bContrast = ((((currentAddress[x] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
       bContrast = (bContrast < 0) ? 0 : (bContrast > 255) ? 255 : bContrast;
       currentAddress[x] = (byte)bContrast;

       double gContrast = ((((currentAddress[x + 1] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
       gContrast = (gContrast < 0) ? 0 : (gContrast > 255) ? 255 : gContrast;
       currentAddress[x + 1] = (byte)gContrast;

       double rContrast = ((((currentAddress[x + 2] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
        rContrast = (rContrast < 0) ? 0 : (rContrast > 255) ? 255 : rContrast;
        currentAddress[x + 2] = (byte)rContrast;
      }
   }
}

Coding မွာ ခက္ခဲတာ ဘာမွမပါလို႔ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။

private void tbContrast_Scroll(object sender, EventArgs e)
{
   int threshold = tbContrast.Value - 100;
   lblContrast.Text = threshold.ToString();
   if (picOriginalImg.Image != null) {
      picResultImg.Image = SimpleContrastImage(picOriginalImg.Image, threshold);
   }            
}

ဒါကေေတာ့ TrackBar သို႔မဟုတ္ Contrast Value ရဲ႕ ေျပာင္းလဲအမႈအေပၚ မူတည္ၿပီး Contrast Image ေျပာင္းလဲယူဖို႔အတြက္ Calling Method အေျခအေနပါ။ Track Value ထဲက 100 ျပန္နဳတ္ထားတာကေတာ့ Contrast Value ကို -100 to 100 ၾကား တြက္ယူခ်င္လို႔ပါ။ ေျပာင္းလဲသြားတဲ့ Contrast Value ကိုေတာ့ label နဲ႔ Infornation ထုတ္ျပထားပါတရ္။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Imaging;

namespace ImgProcessing
{
    public partial class frmSimpleContrastImage : Form
    {
        public frmSimpleContrastImage()
        {
            InitializeComponent();
        }

        private void btnLoadImage_Click(object sender, EventArgs e)
        {
            LoadImage(picOriginalImg);

            //For Contrast Image
            tbContrast.Value = 100;
            lblContrast.Text = "0";
            picResultImg.Image = null;
        }

        public void LoadImage(PictureBox pic)
        {
            OpenFileDialog openFD = new OpenFileDialog();
            openFD.Title = "Load an Image";
            openFD.Filter = "JPEG Images|*.Jpg|PNG Images|*.Png|GIF Images|*.Gif|BITMAP Images|*.Bmp";
            if (openFD.ShowDialog() == DialogResult.OK) {
                pic.Image = Image.FromFile(openFD.FileName);
            }
        }

        private void tbContrast_Scroll(object sender, EventArgs e)
        {
            int threshold = tbContrast.Value - 100;
            lblContrast.Text = threshold.ToString();
            if (picOriginalImg.Image != null) {
                picResultImg.Image = SimpleContrastImage(picOriginalImg.Image, threshold);
            }            
        }

        public Image SimpleContrastImage(Image inputImg, int threshold)
        {
            Bitmap cloneImg = new Bitmap(inputImg);
            Rectangle rect = new Rectangle(0, 0, cloneImg.Width, cloneImg.Height);
            BitmapData bmpData = cloneImg.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            Unsafe {
                byte* ptrAddress = (byte*)bmpData.Scan0;
                double contrast = Math.Pow((100.0 + threshold) / 100.0, 2);
                for (int y = 0; y < bmpData.Height; y++) {
                    byte* currentAddress = ptrAddress + (y * bmpData.Stride);
                    for (int x = 0; x < bmpData.Stride; x += 3) {
                        double bContrast = ((((currentAddress[x] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
                        bContrast = (bContrast < 0) ? 0 : (bContrast > 255) ? 255 : bContrast;
                        currentAddress[x] = (byte)bContrast;

                        double gContrast = ((((currentAddress[x + 1] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
                        gContrast = (gContrast < 0) ? 0 : (gContrast > 255) ? 255 : gContrast;
                        currentAddress[x + 1] = (byte)gContrast;

                        double rContrast = ((((currentAddress[x + 2] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
                        rContrast = (rContrast < 0) ? 0 : (rContrast > 255) ? 255 : rContrast;
                        currentAddress[x + 2] = (byte)rContrast;
                    }
                }      
                //////////OR///////////
                //byte* ptrAddress = (byte*)bmpData.Scan0;
                //double contrast = Math.Pow((100.0 + threshold) / 100.0, 2);
                //int totalByte = bmpData.Height * bmpData.Stride;
                //for (int i = 0; i < totalByte; i++) {
                //    double fContrast = ((((ptrAddress[i] / 255.0) - 0.5) * contrast) + 0.5) * 255.0;
                //    fContrast = (fContrast < 0) ? 0 : (fContrast > 255) ? 255 : fContrast;
                //    ptrAddress[i] = (byte)fContrast;
                //}
            }
            cloneImg.UnlockBits(bmpData);
            return cloneImg;
        }
    }
}

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။