WLC_Programming Knowledge

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ 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 အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။ က်ေနာ္ကေတာ့ ေအာက္ကပံုအတိုင္း ပံုစံခ်ထားပါတရ္ဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ GUI ကို ႀကိဳက္သလို ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္ဗ်။ 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; } } } မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# နဲ႔ Image တစ္ခုကို Gamma Algorithm ကိုအသံုးျပဳၿပီးေတာ့ Color ေတြကို Control လုပ္ႏိုင္တာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ Gamma ဆိုတာ non-linear operation တစ္ခုပါ။ Gamma correction, gamma non-linearity, gamma encoding, ... စသည္ျဖင့္ အမ်ိဳးမ်ိဳးေခၚေ၀ၚၾကပါတရ္။ မည္သို႔ပင္ဆိုေစ Gamma ရဲ႕ အလုပ္ကေတာ့ Image တစ္ခုရဲ႕ light and dark တန္ဖိုးေတြကို encode and decond လုပ္ဖို႔ပါ။ တစ္နည္းအားျဖင့္ Brightness ကို Control လုပ္တာပါ။ အလင္း/အေမွာင္ကို control လုပ္တရ္ဆုိလို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Brightness နဲ႔ သြားမေရာေစခ်င္ပါ။ Gamma Operation က Brightness Operation နဲ႔ ပိုၿပီးရႈပ္ေထြးပါတရ္။ Gamma Algorithm ကိုေတာ့ အလင္း/အေမွာင္ ပံုစံ မမွန္ေသာ Image မ်ားကို မိမိစိတ္ႀကိဳက္ R, G, B Color Value ကို Brithtness ကစားၿပီး encode လုပ္တဲ့အခ်ိန္မွာ သံုးပါတရ္။ Brightness တုန္းက R, G, B Color value ကို -255 to 255 နဲ႔ radio တစ္ခုတည္းမွာ ကစားႏိုင္ေပမဲ့ Gamma မွာေတာ့ 0.2 to 5 ၾကားမွာ R, G, B Color Value ကို channel တစ္ခုစီအလိုက္ ကစားႏိုင္ပါလိမ့္မရ္။ ေအာက္မွာ Algorithm နဲ႔ Example ေလးကို ၾကည့္လိုက္ရင္ နားလည္သြာပါလိမ့္မရ္။ Algorithm: 1. Get the RGB value of the pixel. 2. Calculate new RGB values as follows: R = (255.0 * Math.Pow(Original_Red / 255.0, 1.0 / redGamma)); G = (255.0 * Math.Pow(Original_Green / 255.0, 1.0 / greenGamma)); B = (255.0 * Math.Pow(Original_Blue / 255.0, 1.0 / blueGamma)); 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); Gamma Processing => redGamma = 1.25; Red = (255.0 * Math.Pow(120/255.0, 1.0/1.25)); = (255.0 Math.Pow(0.47,0.8)); = (255.0 * 0.547) = 139.525; အနည္းငယ္ ရွင္းျပရမရ္ဆိုရင္ေတာ့... ပထမဦးဆံုး Pixel ကို Detect လုပ္ၿပီး RGB Color Value ေတြကို ဆြဲထုတ္ပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ ရလာတဲ့ RGB Color Value ေတြကို Gamma Formula ထဲကိုျဖတ္ၿပီး RGB Color Value အသစ္ေတြကို ဖန္တီးယူပါတရ္။ Gamma Formula ပံုစံကေတာ့...
RGB = (255.0 * Math.Pow(Original_Color / 255.0, 1.0 / Gamma));
အခုလိုျဖစ္ပါတရ္။ တတိယအဆင့္မွာေတာ့ ရရွိလာတဲ့ Color Value အသစ္ေတြကို မူလ Pixel ရဲ႕ RGB Color Value ေနရာေတြမွာ ျပန္အစားထိုးလိုက္တာပါ။ ဒီနည္းအတိုင္း last Pixel ေရာက္သည္အထိ တြက္ထုတ္ၿပီး Gamma Image တစ္ခုအျဖစ္ ဖန္တီးယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။ ဥပမာအေနနဲ႔ေတာ့ က်ေနာ္ Red Color တစ္ခုကို Gramma တြက္ျပထားပါတရ္။ နားလည္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ အထက္မွာရွင္းျပခဲ့တာကေတာ့ Gamma Algorithm ရဲ႕ Color Encode Formual ပံုစံပါ။ မိတ္ေဆြတို႔အေနနဲ႔ Gamma ခ်ိန္ယူၿပီးသား Image တစ္ခုကို မူလပံုစံ သို႔မဟုတ္ ႀကိဳက္ႏွစ္သက္ရာ Color နဲ႔ Decode ျပန္လုပ္ခ်င္တရ္ဆိုရင္ျဖင့္ ေအာက္က Formula ကို ျပန္သံုးႏိုင္ပါတရ္ဗ်။
Original = 255.0 * Math.Pow(encode/255.0, gamma);
အေပၚမွာ က်ေနာ္ Red Color 120 ကုိ Gamma ကုိသံုးၿပီး Encode လုပ္ခဲ့တာ 139 ရခဲ့ပါတရ္။ မိတ္ေဆြတို႔အေနနဲ႔ ဒီ Decode Formual ကိုသံုးၿပီး Decode ျပန္လုပ္ၾကည့္ပါ။ Red Color 120 ျပန္ရပါလိမ့္မရ္ဗ်။
မွတ္ခ်က္။ Gamma Input range က 0.2 to 5 အထိပဲရွိတာကို သတိျပဳပါ။ Gamma Value = 1 က Gamma Processing မလုပ္ရေသးတဲ့ မူလ Color Value ျဖစ္ၿပီး 1 နဲ႔ 0.2 ၾကားကေတာ့ အေမွာင္ဘက္ကို Control လုပ္မရ္႕ Gamma Value ျဖစ္ပါတရ္။ 1 to 5 ကေတာ့ အလင္းဘက္သို႔ Control လုပ္မရ္႕ Gamma Value ပဲျဖစ္ပါတရ္ဗ်ာ။

ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ Gamma Algorithm ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ GUI ေဖာက္ Coding ေရးၿပီး လက္ေတြ႔ေလ့လာၾကည့္ရေအာင္။ ဒါကေတာ့ က်ေနာ္တို႔ Project မွာ အသံုးျပဳမရ္ Library File ေတြပါ။ using System; using System.Drawing; using System.Windows.Forms; using System.Drawing.Imaging; ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(2)ခုနဲ႔ PictureBox(2)ခု၊ TrackBar(3)ခုနဲ႔ Label(3)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။ က်ေနာ္ကေတာ့ ေအာက္ကပံုအတိုင္း ပံုစံခ်ထားပါတရ္ဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ GUI ကို ႀကိဳက္သလို ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္ဗ်။ ဒီမွာ TrackBar ရဲ႕ Range ကို 4 to 100 ေပးထားတာကေတာ့ က်ေနာ္တို႔ Gamma ရဲ႕ Inupt Range ျဖစ္တဲ့ 0.2 to 5 ၾကား ကစားႏိုင္ေအာင္ပါ။ 4 to 100 ေပးၿပီး 0.2 to 5 ျဖစ္ေအာင္ က်ေနာ္ကေတာ့ ေအာက္ကပံုစံအတိုင္း တြက္ထုတ္ထားပါတရ္။
Gamma = 0.05 * TrackBarValue;
အခုလိုပါ။ TrackBar ရဲ႕ lower bound ျဖစ္တဲ့ 4 ကို 0.05 နဲ႔ေျမွာက္ၾကည့္ပါ။ က်ေနာ္တို႔ Gamma Value ရဲ႕ lower bound ျဖစ္တဲ့ 0.2 ကိုရပါလိမ့္မရ္။ ဒီလိုပါပဲ TrackBar ရဲ႕ upper bound ျဖစ္တဲ့ 100 ကို 0.05 နဲ႔ေျမွာက္ၾကည့္ပါ။ က်ေနာ္တို႔ Gamma Value ရဲ႕ upper bound ျဖစ္တဲ့ 5 ကိုရပါလိမ့္မရ္ဗ်ာ။ ဒါဆိုရင္ေတာ့ TrackBar ကိုႀကိဳက္သလိုကစားရင္ေတာင္ က်ေနာ္တို႔ လိုခ်င္ေနတဲ့ Gamma Input Range ျဖစ္တဲ့ 0.2 to 5 ၾကားပဲ ရွိေနပါလိမ့္မရ္ဗ်။ logic ကေတာ့ သခၤ်ာကို အေျခခံထားပါတရ္။ Math အားေကာင္းရင္ျဖင့္ Programming Logic ေကာင္းပါလိမ့္မရ္ဗ်ာ။ ေလ့လာၾကပါလို႔ တိုက္တြန္းပါရေစ။

ဒီေလာက္ဆိုရင္ေတာ့ က်ေနာ္တို႔ Gamma Processing မွာ အသံုးျပဳမရ္႕ Algorithm ေတြ logic ေတြ အၾကမ္းဖ်ဥ္းနားလည္သြားပါၿပီ။ က်ေနာ္တို႔ Coding ေရးၾကည့္ၾကမရ္။ float redGamma = 1f, greenGamma=1f, blueGamma=1f; private void btnLoadImage_Click(object sender, EventArgs e) { LoadImage(picOriginalImg); //For Gamma lblRedGamma.Text = lblGreenGamma.Text = lblBlueGamma.Text = "1"; tbRedGamma.Value = tbGreenGamma.Value = tbBlueGamma.Value = 20; } ဒါကေတာ့ ပထမဆံုး Processing လုပ္မရ္႕ Image ကို PictureBox ေပၚသို႔ ဆြဲတင္တဲ့အခ်ိန္မွာပဲ Gamma Processing အတြက္ လိုအပ္တာမ်ားကို Initial လုပ္လိုက္တာပါ။ Global အေနနဲ႔ redGamma, greenGamma, blueGamma တို႔ကို 1 assign လုပ္ထားတာကေတာ့ က်ေနာ္အေပၚမွတ္ခ်က္မွာ ေျပာခဲ့တဲ့အတိုင္း Image ကို Gamma Processing မလုပ္ရေသးတဲ့ 1 အေျခအေနမွာ initial လုပ္ခ်င္လို႔ပါ။ ကနဦးမွာ user information အျဖစ္ label ေတြနဲ႔ Gamma value ေတြကို 1 ေပးထားပါတရ္။ ေနာက္ TrackBar Value ေတြကို 20 ေပးထားတာကလည္း Gamma Processing မလုပ္ရေသးတဲ့ 1 အေျခအေနမွာ initial လုပ္ခ်င္လို႔ပါပဲ(Gamma = 20 * 0.05 = 1)။ နားလည္ႏိုင္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ public Image GammaImage(Image inputImg, float rGamma, float gGamma, float bGamma) { 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* ptrFirstAddress = (byte*)bmpData.Scan0; for (int y = 0; y < bmpData.Height; y++) { byte* currentAddress = ptrFirstAddress + (y * bmpData.Stride); for (int x = 0; x < bmpData.Stride; x+=3) { currentAddress[x] = (byte)(255.0 * Math.Pow(currentAddress[x] / 255.0, 1.0 / bGamma)); currentAddress[x + 1] = (byte)(255.0 * Math.Pow(currentAddress[x + 1] / 255.0, 1.0 / gGamma)); currentAddress[x + 2] = (byte)(255.0 * Math.Pow(currentAddress[x + 2] / 255.0, 1.0 / rGamma)); } } } cloneImg.UnlockBits(bmpData); return cloneImg; } ဒါကေတာ့ Gamma Processing အတြက္ Method ခြဲေရးထားတာပါ။ Method ကိုေတာ့ Processing လုပ္မရ္႕ Image နဲ႔အတူ RGB Gamma Value ေတြကို Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ R, G, B Color Value ေတြကို Gamma ေျပာင္းယူပံုအဆင့္ဆင့္ကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။ Coding မွာ ခက္ခဲတာ ဘာမွမပါလို႔ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ private void tbRedGamma_Scroll(object sender, EventArgs e) { redGamma = 0.05f * tbRedGamma.Value; lblRedGamma.Text = redGamma.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, redGamma, greenGamma, blueGamma); } } private void tbGreenGamma_Scroll(object sender, EventArgs e) { greenGamma = 0.05f * tbGreenGamma.Value; lblGreenGamma.Text = greenGamma.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, redGamma, greenGamma, blueGamma); } } private void tbBlueGamma_Scroll(object sender, EventArgs e) { blueGamma = 0.05f * tbBlueGamma.Value; lblBlueGamma.Text = blueGamma.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, redGamma, greenGamma, blueGamma); } } ဒါကေေတာ့ TrackBar သို႔မဟုတ္ RBG Gamma Value ေတြရဲ႕ ေျပာင္းလဲအမႈအေပၚ မူတည္ၿပီး Gamma Image ေျပာင္းလဲယူဖို႔အတြက္ Calling Method အေျခအေနပါ။ RBG Gamma Value ေတြအတြက္ Track Bar သံုးခုကို သံုးထားတဲ့အတြက္ TrackBar သံုးခုစလံုးမွ Method ကို Calling လုပ္ထားပါတရ္။ Coding ကေတာ့ အရမ္းကို ရိုးရွင္းပါတရ္။ Gamma Method က သတ္မွတ္ထားတဲ့ Parameter အတိုင္း Value ေတြကို မွန္မွန္ကန္ကန္ Assign လုပ္ေပးလိုက္ယံုပါပဲဗ်ာ။ if( )statement နဲ႔စစ္ထားတာကေတာ့ Processing လုပ္မရ္႕ Image ကုိဆြဲတင္ၿပီး ရွိ/မရွိ သိခ်င္လို႔ပါ။ Default Image အတြက္ေတာ့ ရိုးရိုးရွင္းရွင္းပါပဲ။ အားလံုးကို Gamma Processing မလုပ္ရေသးတဲ့ အေျခအေနကို ျပန္ပို႔ထားလိုက္တာပါ။ မိတ္ေဆြတို႔ အားလံုးကို ၿခံဳငံုနားလည္သြားေအာင္ ေအာက္မွာ Coding အျပည့္အစံုကို ေလ့လာႏိုင္ပါတရ္ဗ်။ using System; using System.Drawing; using System.Windows.Forms; using System.Drawing.Imaging; namespace ImgProcessing { public partial class frmGammaImage : Form { public frmGammaImage() { InitializeComponent(); } float redGamma = 1f, greenGamma=1f, blueGamma=1f; private void btnLoadImage_Click(object sender, EventArgs e) { LoadImage(picOriginalImg); //For Gamma lblRedGamma.Text = lblGreenGamma.Text = lblBlueGamma.Text = "1"; tbRedGamma.Value = tbGreenGamma.Value = tbBlueGamma.Value = 20; } 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 tbRedGamma_Scroll(object sender, EventArgs e) { redGamma = 0.05f * tbRedGamma.Value; lblRedGamma.Text = redGamma.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, redGamma, greenGamma, blueGamma); } } private void tbGreenGamma_Scroll(object sender, EventArgs e) { greenGamma = 0.05f * tbGreenGamma.Value; lblGreenGamma.Text = greenGamma.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, redGamma, greenGamma, blueGamma); } } private void tbBlueGamma_Scroll(object sender, EventArgs e) { blueGamma = 0.05f * tbBlueGamma.Value; lblBlueGamma.Text = blueGamma.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, redGamma, greenGamma, blueGamma); } } public Image GammaImage(Image inputImg, float rGamma, float gGamma, float bGamma) { 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* ptrFirstAddress = (byte*)bmpData.Scan0; for (int y = 0; y < bmpData.Height; y++) { byte* currentAddress = ptrFirstAddress + (y * bmpData.Stride); for (int x = 0; x < bmpData.Stride; x+=3) { currentAddress[x] = (byte)(255.0 * Math.Pow(currentAddress[x] / 255.0, 1.0 / bGamma)); currentAddress[x + 1] = (byte)(255.0 * Math.Pow(currentAddress[x + 1] / 255.0, 1.0 / gGamma)); currentAddress[x + 2] = (byte)(255.0 * Math.Pow(currentAddress[x + 2] / 255.0, 1.0 / rGamma)); } } } cloneImg.UnlockBits(bmpData); return cloneImg; } private void btnDefaultImg_Click(object sender, EventArgs e) { if (picOriginalImg.Image != null) { picResultImg.Image = GammaImage(picOriginalImg.Image, 1f, 1f, 1f); } lblRedGamma.Text = lblGreenGamma.Text = lblBlueGamma.Text = "1"; tbRedGamma.Value = tbGreenGamma.Value = tbBlueGamma.Value = 20; } } } မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# ကို အသံုးျပဳၿပီး Image တစ္ခုကို Negative View ပုံစံနဲ႔ ထုတ္ၾကည့္ႏိုင္တာေလးကို ေလ့လာၾကည့္ပါ့မရ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ ဖလင္ကင္မရာေတြေခာတ္ကို မွီခဲ့တဲ့ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမတို႔အတြက္ေတာ့ Negative Image ဆိုတာကို သိၾကမရ္ထင္ပါတရ္။ Negative Film လိပ္ေလးေတြကို တယုတယသိမ္းၿပီး ဓါတ္ပံုအျဖစ္ ျပန္ျပန္ကူးယူခဲ့ၾကရတာကိုဗ်။ Negative ဆိုတာက ရုိးရိုးရွင္းရွင္း ေျပာရရင္ Invert လုပ္လိုက္တာပါ။ 1 ဆိုရင္ 0 ေျပာင္း၊ အျဖဴဆိုအမဲ ေျပာင္းလိုက္တာေပါ့။ Pixel တစ္ခုစီမွာရွိတဲ့ Color ေတြကို Invert လုပ္ပစ္ႏိုင္မွာသာ က်ေနာ္တို႔လိုခ်င္တဲ့ Negative Image တစ္ခုကိုရရွိမွာ မဟုတ္လားဗ်။ Color Range 0 to 255 ၾကားမွ ဘာျဖစ္လာမရ္မွန္းမသိတဲ့ Color Value ကို Invert လုပ္ဖို႔ တစ္ခုတည္းေသာ နည္းလမ္းရွိပါတရ္။ ဒါကေတာ့ Color ရဲ႕ Upper Bound ျဖစ္တဲ့ 255 ထဲက Detect လုပ္လုိ႔ရရွိတဲ့ Color Value ကိုႏုတ္လိုက္ယံုပါပဲ။ ေအာက္မွာ အဆင့္လိုက္ အေသးစိတ္ Algorithm ေလးကို ၾကည့္လိုက္ပါ။ Algorithm: 1. Get the RGB value of the pixel. 2. Calculate new RGB values as follows: - R = 255 – R - G = 255 – G - B = 255 – B 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: Pixel = RGB(120, 80, 200); Negative Processing, Pixel = RGB(255-120, 255-80, 255-200); = RGB(135, 175, 55); အနည္းငယ္ ရွင္းျပရမရ္ဆိုရင္ေတာ့... ပထမအဆင့္မွာ Image ရဲ႕ Pixel တစ္ခုကို Detect လုပ္ၿပီး R, G, B Color Value ေတြကို ဆြဲထုတ္ယူပါတရ္။ ဒုတိယအဆင့္မွာေတာ့ Color range ရဲ႕ Upper Bound ျဖစ္တဲ့ 255 ထဲက Detect ရရွိေသာ R, G, B Color တန္ဖိုးေတြကို နဳတ္ပါတရ္။ တတိယအဆင့္မွာေတာ့ အသစ္ရရွိလာေသာ R, G, B တန္ဖိုးေတြကို မူလ Pixel ရဲ႕ R, G, B Color တန္ဖိုးေတြေနရာကို ျပန္အစားထိုးလိုက္တာပါ။ ဒီနည္းလမ္းအတိုင္းပဲ Last Pixel ေရာက္သည္အထိ အလုပ္လုပ္ေစၿပီး Color Image တစ္ခုကို Negative Image အျဖစ္သို႔ ေျပာင္းလဲယူလိုက္တာပဲ ျဖစ္ပါတရ္ဗ်။ ဥပမာေလးနဲ႔တြဲၿပီးရွင္းထားလို႔ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္။
မွတ္ခ်က္။ ဒီ Algorithm က Color Image ကုိ Negative Image အျဖစ္ ေျပာင္းလဲႏိုင္သလို၊ Negative Image ကို Color Image အျဖစ္ ျပန္လည္ေျပာင္းလဲယူႏိုင္ပါတရ္ဗ်။

ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ Negative Algorithm ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ 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 ကို ႀကိဳက္သလို ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္ဗ်။

NegativeImage( ) Method ေလးကို ေလ့လာၾကည့္ပါ့မရ္။ Button Click_Event ကိုသာ သံုးထားတဲ့အတြက္ေၾကာင့္ Negative Image Button ကို D_Click ေပးၿပီး ေအာက္ပါ Coding ေလးကို ေရးယူလိုက္ပါဗ်ာ။ public Image NegativeImage(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* ptrFirstAddress = (byte*)bmpData.Scan0; for (int y = 0; y < bmpData.Height; y++) { byte* currentAddress = ptrFirstAddress + (y * bmpData.Stride); for (int x = 0; x < bmpData.Stride; x+=3) { currentAddress[x] = (byte)(255 - currentAddress[x]); currentAddress[x+1] = (byte)(255 - currentAddress[x+1]); currentAddress[x+2] = (byte)(255 - currentAddress[x+2]); } } } cloneImg.UnlockBits(bmpData); return cloneImg; } Method ကိုေတာ့ Processing လုပ္မရ္႕ Image ကုိ Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ R, G, B Color Value ေတြကို Invert ေျပာင္း Negative လုပ္ယူပံုအဆင့္ဆင့္ကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။ Coding မွာ ခက္ခဲတာ ဘာမွမပါလို႔ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ private void btnNegative_Click(object sender, EventArgs e) { if (picOriginalImg.Image != null) { picResultImg.Image = NegativeImage(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 frmNegativeImage : Form { public frmNegativeImage() { 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 btnNegative_Click(object sender, EventArgs e) { if (picOriginalImg.Image != null) { picResultImg.Image = NegativeImage(picOriginalImg.Image); } } public Image NegativeImage(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* ptrFirstAddress = (byte*)bmpData.Scan0; for (int y = 0; y < bmpData.Height; y++) { byte* currentAddress = ptrFirstAddress + (y * bmpData.Stride); for (int x = 0; x < bmpData.Stride; x+=3) { currentAddress[x] = (byte)(255 - currentAddress[x]); currentAddress[x+1] = (byte)(255 - currentAddress[x+1]); currentAddress[x+2] = (byte)(255 - currentAddress[x+2]); } } } cloneImg.UnlockBits(bmpData); return cloneImg; } } } မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

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

Brightness က အလင္း/အေမွာင္ ခ်ိန္ယူတာလို႔ ေျပာခဲ့ပါတရ္။ ဒီေတာ့ Brightness ကို ေလ့လာတဲ့အခါ အလင္းနဲ႔အေမွာင္ဆိုၿပီ ႏွစ္ပိုင္းခြဲၿပီး ေလ့လာႏိုင္ပါတရ္။ အလင္းဘက္ကိုပဲသြားသြား၊ အေမွာင္ဘက္ကိုပဲသြားသြား Color range က (0 to 255) သာရွိလို႔ ဒီ scope ထဲက လြတ္သြားလို႔မရပါဘူး။ ဒီေတာ့ က်ေနာ္တုိ႔ အလင္း/အေမွာင္ကို ကစားလို႔ရတဲ့ Range က (-255 to +255) ေပါ့။

Algorithm ကိုခ်ဥ္းကပ္တဲ့ ပံုစံကေတာ့ ထူးထူးျခားျခားမရွိပါဘူးဗ်။ ပထမဦးဆံုး Pixel တစ္ခုကို Detect လုပ္ၿပီး R, G, B Color Value ေတြကို ဆြဲထုတ္ပါတရ္။ ရလာတဲ့ R, G, B တန္ဖိုးေတြကိုမွ မိမိတို႔လိုခ်င္တဲ့ အလင္း/အေမွာင္ တန္ဖိုးနဲ႔ ေပါင္းေပးၿပီး မူရင္း Pixel ရဲ႕ R, G, B value ေတြထဲ ျပန္ထည့္ေပးလိုက္တာပါ။ အလင္းဘက္သြားခ်င္ရင္ အေပါင္းတန္ဖိုးနဲ႔ ေပါင္းမရ္။ အေမွာင္ဘက္သြားခ်င္ရင္ အႏုတ္တန္ဖိုးနဲ႔ ေပါင္းေပးယံုေပါ့။ ဥပမာ အလင္းဘက္ကို သြားမရ္ဆိုပါစို႔-
Brightness Value = 45;
Pixel = RGB(120, 114, 50);
Brightness Processing,
Pixel = RGB(120+45, 114+45, 50+45); = RGB(165, 159, 95);

ဒီလိုပါပဲ။ အေမွာင္ဘက္ကို သြားမရ္ဆိုရင္ေတာ့...
Brightness Value = -45;
Pixel = RGB(120, 114, 50);
Brightness Processing,
Pixel = RGB(120+(-45), 114+(-45), 50+(-45)); = RGB(75, 69, 5);
ကဲ... ဒီေလာက္ဆိုရင္ေတာ့ Brightness Algorithm ရဲ႕ သေဘာတရားကို သိၿပီလို႔ ထင္ပါတရ္။ က်ေနာ္တို႔ GUI ေဖာက္ Coding ေရးၿပီး လက္ေတြ႔ေလ့လာၾကည့္ရေအာင္။ ဒါကေတာ့ က်ေနာ္တို႔ Project မွာ အသံုးျပဳမရ္ Library File ေတြပါ။ using System; using System.Drawing; using System.Windows.Forms; using System.Drawing.Imaging; ဒီေန႔ ေလ့က်င့္ခန္းအတြက္ GUI တည္ေဆာက္ျခင္းအပိုင္းမွာေတာ့ က်ေနာ္ Button(1)ခု၊ Label(1)ခု၊ PictureBox(2)ခုနဲ႔ TrackBar(1)ခုကို အသံုးျပဳထားပါတရ္။ Tools ေတြရဲ႕ Properties ေတြကိုေတာ့ ေအာက္က Table အတိုင္း ျပင္ယူလိုက္ၾကပါဗ်ာ။ က်ေနာ္ကေတာ့ ေအာက္ကပံုအတိုင္း ပံုစံခ်ထားပါတရ္ဗ်ာ။ မိတ္ေဆြတို႔အေနနဲ႔ေတာ့ GUI ကို ႀကိဳက္သလို ပံုေဖာ္ ဖန္တီးႏိုင္ပါတရ္ဗ်။

ဒီေန႔ ေလ့က်င့္ခန္းမွာေတာ့ Brightness Processing အတြက္ TrackBar ကိုသံုးထားပါတရ္။ TrackBar ကို Initial Value = 255 ေပးထားတာကေတာ့ Brightness In/Out အတြက္ TrackBar ကို စမွတ္ 255 မွာ Zero Line ခ်လိုက္တာပါ။ ဒါမွ ကနဦး ဆြဲတင္လိုက္ေသာ Image ဟာ 255(0%)မွာ ေဖာ္ျပၿပီး 255 ေအာက္ငယ္သြားရင္ Bright Out Process ျဖစ္တဲ့ အေမွာင္ဘကိုကုိလုပ္္ကာ 255 ထက္မ်ားသြားရင္ေတာ့ Bright In Process ျဖစ္တဲ့ အလင္းဘက္ကိုလုပ္ပါလို႔ ခိုင္းလို႔ရမွာပါ။ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္။ ဒီေတာ့ TrackBar ရဲ႕ Value အခ်ိန္းအေျပာင္းေပၚမူတည္ၿပီး Brightness Result ေျပာင္းလဲ လုပ္ေဆာင္သြားမွာျဖစ္ပါတရ္။ TrackBar ကို D-Click ေပးၿပီး ေအာက္က Method ေလးကို ေရးယူလိုက္ပါဗ်ာ။ public Image BrightnessImage(Image inputImg, int brightnessValue) { 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* ptrFirstAddress = (byte*)bmpData.Scan0; for (int y = 0; y < bmpData.Height; y++) { byte* currentAddress = ptrFirstAddress + (y * bmpData.Stride); for (int x = 0; x < bmpData.Stride; x = x+3) { int blueBrightness = currentAddress[x] + brightnessValue; blueBrightness = (blueBrightness < 0) ? 0 : (blueBrightness > 255) ? 255 : blueBrightness; currentAddress[x] = (byte)blueBrightness; int greenBrightness = currentAddress[x+1] + brightnessValue; greenBrightness = (greenBrightness < 0) ? 0 : (greenBrightness > 255) ? 255 : greenBrightness; currentAddress[x+1] = (byte)greenBrightness; int redBrightness = currentAddress[x+2] + brightnessValue; redBrightness = (redBrightness < 0) ? 0 : (redBrightness > 255) ? 255 : redBrightness; currentAddress[x+2] = (byte)redBrightness; } } } cloneImg.UnlockBits(bmpData); return cloneImg; } Method ကိုေတာ့ Processing လုပ္မရ္႕ Image နဲ႔ Brightness Changing အတြက္ Value ကုိ Parameter Passing လုပ္ထားပါတရ္။ Pixel Detection လုပ္တဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ က်ေနာ္တို႔ ေရွ႕မွာေလ့လာခဲ့ၿပီးျဖစ္တဲ့ Fast Image Processing ေလ့က်င့္ခန္းအတိုင္း Detect လုပ္ထားပါတရ္။ နားမလည္ေသးတဲ့ မိတ္ေဆြတို႔အတြက္ ေရွ႕သင္ခန္းစာေတြကို ျပန္ဖတ္ေပးပါလို႔ တိုက္တြန္းပါရေစ။ R, G, B Brightness Value အတိုး/အေလွ်ာ့ လုပ္သြားတဲ့ပုံကိုေတာ့ က်ေနာ္ အေပၚမွာ ဥပမာနဲ႔ အေသစိတ္ရွင္းျပခဲ့ပါတရ္။ Coding မွာ ခက္ခဲတာ ဘာမွမပါလို႔ နားလည္ၾကလိမ့္မရ္လို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။ private void tbBrightnessValue_Scroll(object sender, EventArgs e) { int brightness = tbBrightnessValue.Value - 255; lblBrightnessValue.Text = brightness.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = BrightnessImage(picOriginalImg.Image, brightness); } } ဒါကေတာ့ 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 frmBrightnessImage : Form { public frmBrightnessImage() { InitializeComponent(); } private void btnLoadImage_Click(object sender, EventArgs e) { LoadImage(picOriginalImg); //For Brightness tbBrightnessValue.Value = 255; lblBrightnessValue.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 tbBrightnessValue_Scroll(object sender, EventArgs e) { int brightness = tbBrightnessValue.Value - 255; lblBrightnessValue.Text = brightness.ToString(); if (picOriginalImg.Image != null) { picResultImg.Image = BrightnessImage(picOriginalImg.Image, brightness); } } public Image BrightnessImage(Image inputImg, int brightnessValue) { 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* ptrFirstAddress = (byte*)bmpData.Scan0; for (int y = 0; y < bmpData.Height; y++) { byte* currentAddress = ptrFirstAddress + (y * bmpData.Stride); for (int x = 0; x < bmpData.Stride; x = x+3) { int blueBrightness = currentAddress[x] + brightnessValue; blueBrightness = (blueBrightness < 0) ? 0 : (blueBrightness > 255) ? 255 : blueBrightness; currentAddress[x] = (byte)blueBrightness; int greenBrightness = currentAddress[x+1] + brightnessValue; greenBrightness = (greenBrightness < 0) ? 0 : (greenBrightness > 255) ? 255 : greenBrightness; currentAddress[x+1] = (byte)greenBrightness; int redBrightness = currentAddress[x+2] + brightnessValue; redBrightness = (redBrightness < 0) ? 0 : (redBrightness > 255) ? 255 : redBrightness; currentAddress[x+2] = (byte)redBrightness; } } } cloneImg.UnlockBits(bmpData); return cloneImg; } } } မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။