Implementasi Dan Perbandingan Optimum Notch Filter Dan Band Reject Filter Untuk Mereduksi Periodic Noise Pada Citra Digital

(1)

LISTING PROGRAM

1. Form Pengujian ONF dan BRF

using System;

using System.Collections.Generic; using System.ComponentModel; using System.Data;

using System.Drawing;

using System.Drawing.Imaging; using System.Linq;

using System.Text;

using System.Threading.Tasks; using System.Windows.Forms; namespace SelectiveFilter2 {

public partial class Form1 : Form {

double waktu = 0.0; bool noise;

int[,] dataA; int[,] dataB; struct COMPLEX {

public double real, imag;

public COMPLEX(double x, double y) {

real = x; imag = y; }

public float Magnitude() {

return ((float)Math.Sqrt(real * real + imag * imag)); }

public float Phase() {

return ((float)Math.Atan(imag / real)); }

}

byte[,] r_data; byte[,] g_data; byte[,] b_data; FFT ImgFFT; public Form1() {

InitializeComponent(); }

private void bukaGambarToolStripMenuItem_Click(object sender, EventArgs e)

(2)

openFileDialog.InitialDirectory = "";

openFileDialog.Filter = "Bitmap files(*.bmp)|*.bmp|Jpeg Files(*.jpg)|*.jpg|All valid files " +

"(*.bmp/*.jpg)|*.bmp/*.jpg"; openFileDialog.FilterIndex = 2;

openFileDialog.RestoreDirectory = true;

if (DialogResult.OK == openFileDialog.ShowDialog()) {

this.AutoScroll = true; this.citraAsli.Image = new Bitmap(openFileDialog.FileName);

this.Invalidate();

Bitmap b = new Bitmap((Bitmap)this.citraAsli.Image); dataA = new int[b.Height,b.Height];

dataB = new int[b.Height,b.Height]; if (b.Width == b.Height)

{

LL.Text = b.Width.ToString(); TT.Text = b.Height.ToString(); noise = false;

BitmapData bmdata = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite,

PixelFormat.Format24bppRgb); int stride = bmdata.Stride;

System.IntPtr Scan0 = bmdata.Scan0;

unsafe {

byte* p = (byte*)(void*)Scan0; int nOffset = stride - b.Width * 3; r_data = new byte[b.Width, b.Height]; g_data = new byte[b.Width, b.Height]; b_data = new byte[b.Width, b.Height]; for (int y = 0; y < b.Height; ++y) {

for (int x = 0; x < b.Width; ++x) {

b_data[x, y] = p[0]; g_data[x, y] = p[1]; r_data[x, y] = p[2]; p += 3;

}

p += nOffset; }

}

Bitmap Is = new Bitmap((Bitmap)this.citraAsli.Image);

Sinu_noise periodik = new Sinu_noise(Is); periodik.Period = 200;

(3)

citraNoise.Image = periodik.ResultImage; Bitmap Is4 = new

Bitmap((Bitmap)this.citraAsli.Image);

selectiveFilter.CitraAbu2(Is4); Citra_Gray.Image = null;

Citra_Gray.Image = Is4;

for (int i = 0; i < dataA.GetLength(1); i++) {

for (int j = 0; j < dataA.GetLength(1); j++) {

dataA[i, j] = Is4.GetPixel(i, j).R; }

}

Bitmap Is2 = new Bitmap((Bitmap)this.citraNoise.Image);

selectiveFilter.CitraAbu2(Is2); citraAbu.Image = null;

citraAbu.Image = Is2;

Bitmap Is3 = new Bitmap((Bitmap)this.citraAbu.Image);

ImgFFT = new FFT(Is3); ImgFFT.ForwardFFT(); ImgFFT.FFTShift();

ImgFFT.FFTPlot(ImgFFT.FFTShifted);

citraSpektrum.Image = (Image)ImgFFT.FourierPlot;

Bitmap aa = new Bitmap((Bitmap)this.Citra_Gray.Image); Bitmap bb = new Bitmap((Bitmap)this.citraAbu.Image); }

else {

citraAsli.Image = null;

MessageBox.Show("Lebar dan Tinggi gambar harus sama!", "Gagal", MessageBoxButtons.OK, MessageBoxIcon.Error); }

}

private void simpanGambarToolStripMenuItem_Click(object sender, EventArgs e)

{

Application.Exit(); }

private void groupBox2_Enter(object sender, EventArgs e) {

(4)

private void button1_Click(object sender, EventArgs e) {

if ((citraAsli.Image != null) ||(citraAbu.Image!=null)) {

DateTime satu, dua; double W, D0, n;

if ((W1.Text != "") || (D01.Text != "") || (n1.Text != ""))

{

try {

W = Convert.ToDouble(W1.Text); D0 = Convert.ToDouble(D01.Text); n = Convert.ToDouble(n1.Text); Bitmap Is3 = new

Bitmap((Bitmap)this.citraAbu.Image);

ImgFFT = new FFT(Is3); satu = DateTime.Now; ImgFFT.ForwardFFT(); ImgFFT.FFTShift();

ImgFFT.FFTPlot(ImgFFT.FFTShifted); citraSpektrum.Image =

(Image)ImgFFT.FourierPlot;

ImgFFT.RemoveFFTShift();

double[,] a = new double[ImgFFT.Obj.Width, ImgFFT.Obj.Height];

selectiveFilter.Band_Reject(a, W, D0, ImgFFT.Obj.Width, ImgFFT.Obj.Height, 1, (int)n);

for (int p = 0; p < 5; p++) {

for (int v = 0; v < ImgFFT.Obj.Height; v++)

{

for (int u = 0; u < ImgFFT.Obj.Width; u++)

{

ImgFFT.FFTNormal[u, v].real *= a[u, v];

ImgFFT.Output[u, v].real = ImgFFT.FFTNormal[u, v].real;

ImgFFT.FFTNormal[u, v].imag *= a[u, v];

ImgFFT.Output[u, v].imag = ImgFFT.FFTNormal[u, v].imag;

} } }

ImgFFT.RemoveFFTShift(); ImgFFT.InverseFFT(); dua = DateTime.Now;

(5)

BR_ideal.Image = (Image)ImgFFT.Obj; Bitmap bb;

if (noise == false) {

bb= new Bitmap((Bitmap)this.BR_ideal.Image);

for (int i = 0; i < dataB.GetLength(1); i++)

{

for (int j = 0; j < dataB.GetLength(1); j++)

{

dataB[i, j] = bb.GetPixel(i, j).R;

} }

MSE1.Text = MSEPSNR.HitungMSE2(dataA, dataB).ToString();

PSNR1.Text =

MSEPSNR.HitungPSNR(Convert.ToDouble(MSE1.Text)).ToString(); RT1.Text =

(seli.TotalMilliseconds).ToString(); }

satu = DateTime.Now; ImgFFT = new FFT(Is3); ImgFFT.ForwardFFT(); ImgFFT.FFTShift();

for (int p = 0; p < 1; p++) {

{

(6)

BR_B.Image = (Image)ImgFFT.Obj; if (noise == false)

{

bb = new Bitmap((Bitmap)this.BR_B.Image); for (int i = 0; i < dataB.GetLength(1); i++)

{

} }

PSNR2.Text =

MSEPSNR.HitungPSNR(Convert.ToDouble(MSE2.Text)).ToString(); seli = dua.Subtract(satu); RT2.Text =

for (int p = 0; p < 8; p++) {

{

(7)

}

BR_G.Image = (Image)ImgFFT.Obj; if (noise == false)

{

bb = new Bitmap((Bitmap)this.BR_G.Image); for (int i = 0; i < dataB.GetLength(1); i++)

{

} }

PSNR3.Text =

MessageBox.Show("Proses Filter selesai, tekan tombol simpan untuk menyimpan gambar", "Sukses",

MessageBoxButtons.OK, MessageBoxIcon.Information);

}

catch (Exception ex) {

MessageBox.Show("Masukkan angka, bukan Huruf", "GAGAL!", MessageBoxButtons.OK, MessageBoxIcon.Error); }

} } }

if ((citraAsli.Image != null) || (citraAbu.Image != null))

{

double D0, n;

DateTime satu, dua; int x1x, x2x, y1y, y2y;

if ((DO2.Text != "") || (n2.Text != "") || (x1.Text != "") || (x2.Text != "") || (y1.Text != "") || (y2.Text != "")) {

try {

(8)

x1x = Convert.ToInt32(x1.Text); x2x = Convert.ToInt32(x2.Text); y1y = Convert.ToInt32(y1.Text); y2y = Convert.ToInt32(y2.Text);

Bitmap Is3 = new Bitmap((Bitmap)this.citraAbu.Image);

int[,] K = { { x1x, y1y }, { x2x, y2y } }; selectiveFilter.Optimum_notch(a, K, D0, ImgFFT.Obj.Width, ImgFFT.Obj.Height, 1, (int)n);

ImgFFT.RemoveFFTShift(); for (int p = 0; p < 1; p++) {

{

//MessageBox.Show(a[u, v].ToString());

} } }

ImgFFT.RemoveFFTShift(); ImgFFT.InverseFFT(); dua = DateTime.Now; TimeSpan seli;

ONF_I.Image = (Image)ImgFFT.Obj; Bitmap bb;

if (noise == false) {

bb = new Bitmap((Bitmap)this.ONF_I.Image);

(9)

{

} }

PSNR4.Text =

double[,] a1 = new double[ImgFFT.Obj.Width, ImgFFT.Obj.Height];

int[,] K1 = { { x1x, y1y }, { x2x, y2y } }; selectiveFilter.Optimum_notch(a1, K1, D0, ImgFFT.Obj.Width, ImgFFT.Obj.Height, 2, (int)n);

{

ImgFFT.FFTNormal[u, v].real *= a1[u, v];

ImgFFT.FFTNormal[u, v].imag *= a1[u, v];

} } }

ONF_B.Image = (Image)ImgFFT.Obj; if (noise == false)

(10)

bb = new Bitmap((Bitmap)this.ONF_B.Image);

{

} }

PSNR5.Text =

double[,] a2 = new double[ImgFFT.Obj.Width, ImgFFT.Obj.Height];

{

(11)

ONF_G.Image = (Image)ImgFFT.Obj; if (noise == false)

{

//aa = new Bitmap((Bitmap)this.Citra_Gray.Image); bb = new Bitmap((Bitmap)this.ONF_G.Image);

{

} }

PSNR6.Text =

MessageBoxButtons.OK, MessageBoxIcon.Information); }

} } } }

private void Form1_Load(object sender, EventArgs e) {

waktu = 0.0; noise = false; }

private void timerx_Tick(object sender, EventArgs e) {

}

private void Form1_FormClosed(object sender, FormClosedEventArgs e)

{

(12)

public void SimpanMetod(PictureBox abc) {

if (abc.Image != null) {

Bitmap copy = new Bitmap((Bitmap)abc.Image);

SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.InitialDirectory = "";

saveFileDialog.Filter = "Bitmap Files(*.bmp)|*.bmp|Jpeg Files(*.jpg)|*.jpg|All valid files(*.bmp/*.jpg)|*.bmp/*.jpg";

saveFileDialog.FilterIndex = 2;

saveFileDialog.RestoreDirectory = true;

if (DialogResult.OK == saveFileDialog.ShowDialog()) {

copy.Save(saveFileDialog.FileName); }

} }

SimpanMetod(BR_ideal); }

SimpanMetod(BR_B); }

SimpanMetod(BR_G); }

SimpanMetod(ONF_I); }

SimpanMetod(ONF_B); }

SimpanMetod(ONF_G); }

private void petunjukToolStripMenuItem_Click(object sender, EventArgs e)

{

Form3 bc = new Form3(); bc.ShowDialog();

}

(13)

{

Form4 po = new Form4(); po.ShowDialog();

}

private void bukaGambarNoiseToolStripMenuItem_Click(object sender, EventArgs e)

{

OpenFileDialog openFileDialog = new OpenFileDialog(); openFileDialog.InitialDirectory = "";

openFileDialog.Filter = "Bitmap files(*.bmp)|*.bmp|Jpeg Files(*.jpg)|*.jpg|All valid files " +

"(*.bmp/*.jpg)|*.bmp/*.jpg"; openFileDialog.FilterIndex = 2;

openFileDialog.RestoreDirectory = true;

if (DialogResult.OK == openFileDialog.ShowDialog()) {

this.AutoScroll = true; Form5 po = new Form5(); po.citraAbu.Image = new Bitmap(openFileDialog.FileName);

po.Invalidate();

Bitmap Is3 = new Bitmap((Bitmap)po.citraAbu.Image); po.LL.Text = Is3.Width.ToString();

po.TT.Text = Is3.Height.ToString(); if (Is3.Width == Is3.Height)

{

noise = true;

ImgFFT.FFTPlot(ImgFFT.FFTShifted); po.citraSpektrum.Image =

this.Hide(); po.ShowDialog(); this.Show(); }

else {

MessageBox.Show("Lebar dan Tinggi gambar harus sama!", "Gagal", MessageBoxButtons.OK, MessageBoxIcon.Error); }

} }

SimpanMetod(Citra_Gray); }

(14)

2. Form Implementasi ONF dan BRF

using System;

using System.Collections.Generic; using System.ComponentModel; using System.Data;

using System.Drawing; using System.Linq; using System.Text;

using System.Threading.Tasks; using System.Windows.Forms; namespace SelectiveFilter2 {

public partial class Form5 : Form {

FFT ImgFFT; public Form5() {

InitializeComponent(); }

DateTime satu, dua; double W, D0, n;

if ((W1.Text != "") || (D01.Text != "") || (n1.Text != ""))

{

try {

W = Convert.ToDouble(W1.Text); D0 = Convert.ToDouble(D01.Text); n = Convert.ToDouble(n1.Text); Bitmap Is3 = new

Bitmap((Bitmap)this.citraAbu.Image);

ImgFFT = new FFT(Is3); satu = DateTime.Now; ImgFFT.ForwardFFT(); ImgFFT.FFTShift();

citraSpektrum.Image = (Image)ImgFFT.FourierPlot; ImgFFT.RemoveFFTShift();

for (int p = 0; p < 5; p++) {

for (int v = 0; v < ImgFFT.Obj.Height; v++) {

(15)

} } }

TimeSpan seli = dua.Subtract(satu); BR_ideal.Image = (Image)ImgFFT.Obj;

for (int p = 0; p < 1; p++) {

{

} } }

BR_B.Image = (Image)ImgFFT.Obj;

(16)

for (int p = 0; p < 8; p++) {

{

} } }

BR_G.Image = (Image)ImgFFT.Obj;

MessageBoxButtons.OK, MessageBoxIcon.Information);

}

MessageBox.Show("Masukkan angka, bukan Huruf", "GAGAL!", MessageBoxButtons.OK, MessageBoxIcon.Error);

} } }

double D0, n;

DateTime satu, dua; int x1x, x2x, y1y, y2y;

if ((DO2.Text != "") || (n2.Text != "") || (x1.Text != "") || (x2.Text != "") || (y1.Text != "") || (y2.Text != "")) {

try {

(17)

x1x = Convert.ToInt32(x1.Text); x2x = Convert.ToInt32(x2.Text); y1y = Convert.ToInt32(y1.Text); y2y = Convert.ToInt32(y2.Text);

Bitmap Is3 = new Bitmap((Bitmap)this.citraAbu.Image); satu = DateTime.Now; ImgFFT = new FFT(Is3); ImgFFT.ForwardFFT(); ImgFFT.FFTShift();

citraSpektrum.Image = (Image)ImgFFT.FourierPlot; double[,] a = new double[ImgFFT.Obj.Width,

ImgFFT.Obj.Height];

int[,] K = { { x1x, y1y }, { x2x, y2y } }; selectiveFilter.Optimum_notch(a, K, D0, ImgFFT.Obj.Width, ImgFFT.Obj.Height, 1, (int)n);

{

} } }

ONF_I.Image = (Image)ImgFFT.Obj;

(18)

{

} } }

ONF_B.Image = (Image)ImgFFT.Obj; satu = DateTime.Now;

citraSpektrum.Image = (Image)ImgFFT.FourierPlot; double[,] a2 = new double[ImgFFT.Obj.Width, ImgFFT.Obj.Height];

{

(19)

} } }

ONF_G.Image = (Image)ImgFFT.Obj;

MessageBoxButtons.OK, MessageBoxIcon.Information); }

} } }

public void SimpanMetod(PictureBox abc) {

if (abc.Image != null) {

Bitmap copy = new Bitmap((Bitmap)abc.Image);

SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.InitialDirectory = "";

saveFileDialog.Filter = "Bitmap Files(*.bmp)|*.bmp|Jpeg Files(*.jpg)|*.jpg|All valid files(*.bmp/*.jpg)|*.bmp/*.jpg";

saveFileDialog.FilterIndex = 2;

saveFileDialog.RestoreDirectory = true;

if (DialogResult.OK == saveFileDialog.ShowDialog()) {

copy.Save(saveFileDialog.FileName); }

} }

SimpanMetod(BR_ideal); }

SimpanMetod(BR_B); }

(20)

}

SimpanMetod(ONF_I); }

SimpanMetod(ONF_B); }

SimpanMetod(ONF_G); }

} }

3. Kelas Selective_Filter

using System;

using System.Collections.Generic; using System.Linq;

using System.Text;

using System.Threading.Tasks; using System.Drawing;

using System.Drawing.Drawing2D; using System.Drawing.Imaging;

namespace SelectiveFilter2 {

class selectiveFilter {

public static bool CitraAbu2(Bitmap b) {

BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height),

ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;

System.IntPtr Scan0 = bmData.Scan0;

byte[,] grayx = new byte[b.Width, b.Height]; unsafe

{

byte* p = (byte*)(void*)Scan0; int nOffset = stride - b.Width * 3; for (int y = 0; y < b.Height; ++y) {

grayx[x, y] =(byte) ((p[0] + p[1] + p[2]) / 3);

p += 3; }

(21)

byte* p1 = (byte*)(void*)Scan0; for (int y = 0; y < b.Height; ++y) {

p1[0] = grayx[x, y]; p1[1] = grayx[x, y]; p1[2] = grayx[x, y]; p1 += 3;

}

p1 += nOffset; }

}

b.UnlockBits(bmData); return true;

}

public static void Band_Reject(double[,] H, double W, double D0, int x, int y, int tipe, int n)

{

double[,] D = new double[x, y]; //hitung nilai D[u,v]

for (int v = 0; v < y; v++) {

for (int u = 0; u < x; u++) {

D[u, v] = Math.Sqrt((u * u) + (v * v)); //MessageBox.Show(D[u, v].ToString()); }

}

//hitung nilai filter H[u,v] for (int v = 0; v < y; v++) {

for (int u = 0; u < x; u++) {

if (tipe == 1) {

if ((D[u, v] < (D0 - (W / 2))) || (D[u, v] > (D0 + (W / 2))))

H[u, v] = 1; else

H[u, v] = 0; }

if (tipe == 2) {

H[u, v] = 1 / (1 + Math.Pow((D[u, v] * W) / (Math.Pow(D[u, v], 2) - Math.Pow(D0, 2)), 2 * n));

}

if (tipe == 3) {

H[u, v] = 1 (Math.Pow(Math.E,

-(Math.Pow((Math.Pow(D[u, v], 2) - Math.Pow(D0, 2) / (D[u, v] * W)), 2))));

(22)

}

public static void Optimum_notch(double[,] H, int[,] K, double D0, int x, int y, int tipe, int n)

{

double[,] D1 = new double[x, y]; double[,] D2 = new double[x, y]; double[,] H1 = new double[x, y]; double[,] H2 = new double[x, y]; //hitung nilai D1[u,v] dan D2[u,v] //D1-->Dk, D2-->D-k

for (int v = 0; v < y; v++) {

for (int u = 0; u < x; u++) {

D1[u, v] = Math.Sqrt((Math.Pow((u + K[0, 0]), 2)) + (Math.Pow((v + K[0, 1]), 2)));

D2[u, v] = Math.Sqrt((Math.Pow((u - K[1, 0]), 2)) + (Math.Pow((v - K[1, 1]), 2)));

} }

//hitung nilai filter H[u,v] for (int v = 0; v < y; v++) {

for (int u = 0; u < x; u++) {

if (tipe == 1) {

if ((D1[u, v] <= D0) || D2[u, v] <= D0) H[u, v] = 0;

else

H[u, v] = 1; }

if (tipe == 2) {

H1[u, v] = 1 / (1 + Math.Pow((D0 / D1[u, v]), 2 * n));

H2[u, v] = 1 / (1 + Math.Pow((D0 / D2[u, v]), 2 * n));

H[u, v] = H1[u, v] * H2[u, v]; }

if (tipe == 3) {

H1[u, v] = 1 - Math.Pow(Math.E, -((D1[u, v] * D1[u, v]) / (2 * D0 * D0)));

H2[u, v] = 1 - Math.Pow(Math.E, -((D2[u, v] * D2[u, v]) / (2 * D0 * D0)));

H[u, v] = H1[u, v] * H2[u, v]; }

} }

(23)

} }

4. Kelas MSEPSNR

using System;

using System.Text;

using System.Threading.Tasks; namespace SelectiveFilter2 {

class MSEPSNR {

public static double HitungMSE2(int[,] a, int[,] b) {

double total = 0;

for (int i = 0; i < a.GetLength(1); i++) {

for (int j = 0; j < a.GetLength(1); j++) {

total += Math.Abs(Math.Pow(a[i, j] - b[i, j], 2));

} }

return total / Math.Pow(a.GetLength(1), 2); }

public static double HitungPSNR(double x) {

double hasil, kali;

kali = (255) / Math.Sqrt(x); hasil = 20 * Math.Log10(kali); return hasil;

} } }

5. Kelas Sinu_Noise

using System;

using System.Text;

using System.Drawing.Imaging; namespace SelectiveFilter2 {

class Sinu_noise {

private Bitmap sourceBitmap; /// <summary>

(24)

public Bitmap SourceBitmap {

get { return sourceBitmap; } set { sourceBitmap = value; } }

private Bitmap resultImage; /// <summary>

/// Result image. /// </summary>

public Bitmap ResultImage {

get {

BuildImage();

return resultImage; }

set { resultImage = value; } }

private Color vignetteColor = Color.Black; public Color VignetteColor

{

get { return vignetteColor; } set { vignetteColor = value; } }

private int period = 20; public int Period

{

get { return period; } set { period = value; } }

private double fade = 1; public double Fade

{

get { return fade; } set

{

if (fade > 1) {

fade = 1; }

if (fade < 0) {

fade = 0; }

fade = value; }

}

public Sinu_noise(Bitmap bmp) {

sourceBitmap = bmp;

(25)

//BuildImage(); }

private void BuildImage() {

for (int i = 0; i < sourceBitmap.Width - 1; i++) {

for (int j = 0; j < sourceBitmap.Height - 1; j++) {

//int dX = Math.Min(i, sourceBitmap.Width - i); // int dY = Math.Min(j, sourceBitmap.Height - j); double k = fade * Math.Sin(j * period);

Color color = sourceBitmap.GetPixel(i, j); resultImage.SetPixel(i, j,

DrawUtils.SuperpositionColor(DrawUtils.GetGrayColor(color), color, k));

} } } } }

6. Kelas FFT

using System;

using System.Text;

using System.Drawing.Imaging; using System.Drawing.Drawing2D; namespace SelectiveFilter2 {

struct COMPLEX {

public double real, imag;

public COMPLEX(double x, double y) {

real = x; imag = y; }

public float Magnitude() {

return ((float)Math.Sqrt(real * real + imag * imag)); }

public float Phase() {

return ((float)Math.Atan(imag / real)); }

}

class FFT {

(26)

public int[,] GreyImage; public float[,] FourierMagnitude; public float[,] FourierPhase; float[,] FFTLog; float[,] FFTPhaseLog; public int[,] FFTNormalized; public int[,] FFTPhaseNormalized int nx, ny; int Width, Height;

COMPLEX[,] Fourier;

public COMPLEX[,] FFTShifted; public COMPLEX[,] Output; public COMPLEX[,] FFTNormal; public COMPLEX[,] OutputTemp;

public FFT(Bitmap Input) {

Obj = Input;

Width = nx = Input.Width; Height = ny = Input.Height;

OutputTemp = new COMPLEX[Width, Height]; ReadImage();

}

public FFT(int[,] Input) {

GreyImage = Input;

Width = nx = Input.GetLength(0); Height = ny = Input.GetLength(1); }

public FFT(COMPLEX[,] Input) {

nx = Width = Input.GetLength(0); ny = Height = Input.GetLength(1); Fourier = Input;

}

private void ReadImage() {

int i, j;

GreyImage = new int[Width, Height]; Bitmap image = Obj;

BitmapData bitmapData1 = image.LockBits(new Rectangle(0, 0, image.Width, image.Height),

ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

unsafe {

byte* imagePointer1 = (byte*)bitmapData1.Scan0; for (i = 0; i < bitmapData1.Height; i++)

{

(27)

GreyImage[j, i] = (int)((imagePointer1[0] + imagePointer1[1] + imagePointer1[2]) / 3.0);

//4 bytes per pixel imagePointer1 += 4; }//end for j

//4 bytes per pixel

imagePointer1 += bitmapData1.Stride - (bitmapData1.Width * 4);

}//end for i }//end unsafe

image.UnlockBits(bitmapData1); return;

}

public Bitmap Displayimage() {

int i, j;

Bitmap image = new Bitmap(Width, Height);

BitmapData bitmapData1 = image.LockBits(new Rectangle(0, 0, Width, Height),

unsafe {

byte* imagePointer1 = (byte*)bitmapData1.Scan0; for (i = 0; i < bitmapData1.Height; i++)

{

for (j = 0; j < bitmapData1.Width; j++) {

// write the logic implementation here imagePointer1[0] = (byte)GreyImage[j, i]; imagePointer1[1] = (byte)GreyImage[j, i]; imagePointer1[2] = (byte)GreyImage[j, i]; imagePointer1[3] = (byte)255;

//4 bytes per pixel

imagePointer1 += (bitmapData1.Stride - (bitmapData1.Width * 4));

image.UnlockBits(bitmapData1); return image;// col;

}

public Bitmap Displayimage(int[,] image) {

int i, j;

Bitmap output = new Bitmap(image.GetLength(0), image.GetLength(1));

BitmapData bitmapData1 = output.LockBits(new Rectangle(0, 0, image.GetLength(0), image.GetLength(1)),

unsafe {

(28)

for (i = 0; i < bitmapData1.Height; i++) {

for (j = 0; j < bitmapData1.Width; j++) {

imagePointer1[0] = (byte)image[j, i]; imagePointer1[1] = (byte)image[j, i]; imagePointer1[2] = (byte)image[j, i]; imagePointer1[3] = 255;

//4 bytes per pixel

imagePointer1 += (bitmapData1.Stride - (bitmapData1.Width * 4));

output.UnlockBits(bitmapData1); return output;// col;

}

public void ForwardFFT() {

int i, j;

Fourier = new COMPLEX[Width, Height]; Output = new COMPLEX[Width, Height];

for (i = 0; i <= Width - 1; i++) for (j = 0; j <= Height - 1; j++)

{

Fourier[i, j].real = (double)GreyImage[i, j]; Fourier[i, j].imag = 0;

}

Output = FFT2D(Fourier, nx, ny, 1); return;

}

public void FFTShift() {

int i, j;

FFTShifted = new COMPLEX[nx, ny]; for (i = 0; i <= (ny / 2) - 1; ++i) {

for (j = 0; j <= (nx / 2) - 1; ++j) {

FFTShifted[i + (nx / 2), j + (ny / 2)] = Output[i, j];

FFTShifted[i, j] = Output[i + (nx / 2), j + (ny / 2)];

FFTShifted[i + (nx / 2), j] = Output[i, j + (ny / 2)];

FFTShifted[i, j + (nx / 2)] = Output[i + (nx / 2), j];

} }

(29)

public void RemoveFFTShift() {

int i, j;

FFTNormal = new COMPLEX[nx, ny]; for (i = 0; i <= (nx / 2) - 1; i++) for (j = 0; j <= (ny / 2) - 1; j++) {

FFTNormal[i + (nx / 2), j + (ny / 2)] = FFTShifted[i, j];

FFTNormal[i, j] = FFTShifted[i + (nx / 2), j + (ny / 2)];

FFTNormal[i + (nx / 2), j] = FFTShifted[i, j + (ny / 2)];

FFTNormal[i, j + (nx / 2)] = FFTShifted[i + (nx / 2), j];

} return; }

public void FFTPlot(COMPLEX[,] Output) {

int i, j; float max;

FFTLog = new float[nx, ny]; FFTPhaseLog = new float[nx, ny]; FourierMagnitude = new float[nx, ny]; FourierPhase = new float[nx, ny]; FFTNormalized = new int[nx, ny]; FFTPhaseNormalized = new int[nx, ny]; for (i = 0; i <= Width - 1; i++) for (j = 0; j <= Height - 1; j++) {

FourierMagnitude[i, j] = Output[i, j].Magnitude();

FourierPhase[i, j] = Output[i, j].Phase(); FFTLog[i, j] = (float)Math.Log(1 +

FourierMagnitude[i, j]);

FFTPhaseLog[i, j] = (float)Math.Log(1 + Math.Abs(FourierPhase[i, j]));

}

//Generating Magnitude Bitmap max = FFTLog[0, 0];

for (i = 0; i <= Width - 1; i++) for (j = 0; j <= Height - 1; j++) {

if (FFTLog[i, j] > max) max = FFTLog[i, j]; }

(30)

FFTNormalized[i, j] = (int)(2000 * FFTLog[i, j]); }

//Transferring Image to Fourier Plot

FourierPlot = Displayimage(FFTNormalized); //generating phase Bitmap

FFTPhaseLog[0, 0] = 0; max = FFTPhaseLog[1, 1];

if (FFTPhaseLog[i, j] > max) max = FFTPhaseLog[i, j]; }

FFTPhaseLog[i, j] = FFTPhaseLog[i, j] / max; }

FFTPhaseNormalized[i, j] = (int)(255 * FFTPhaseLog[i, j]);

}

PhasePlot = Displayimage(FFTPhaseNormalized);

}

public void FFTPlot() {

int i, j; float max;

FFTLog = new float[nx, ny]; FFTPhaseLog = new float[nx, ny]; FourierMagnitude = new float[nx, ny]; FourierPhase = new float[nx, ny]; FFTNormalized = new int[nx, ny]; FFTPhaseNormalized = new int[nx, ny]; for (i = 0; i <= Width - 1; i++) for (j = 0; j <= Height - 1; j++) {

FourierMagnitude[i, j] = Output[i, j].Magnitude();

FourierPhase[i, j] = Output[i, j].Phase(); FFTLog[i, j] = (float)Math.Log(1 +

FourierMagnitude[i, j]);

FFTPhaseLog[i, j] = (float)Math.Log(1 + Math.Abs(FourierPhase[i, j]));

}

(31)

if (FFTLog[i, j] > max) max = FFTLog[i, j]; }

FFTLog[i, j] = FFTLog[i, j] / max; }

FFTNormalized[i, j] = (int)(1000 * FFTLog[i, j]); }

FourierPlot = Displayimage(FFTNormalized); //generating phase Bitmap

max = FFTPhaseLog[0, 0];

if (FFTPhaseLog[i, j] > max) max = FFTPhaseLog[i, j]; }

FFTPhaseLog[i, j] = FFTPhaseLog[i, j] / max; }

FFTPhaseNormalized[i, j] = (int)(2000 * FFTLog[i, j]);

}

PhasePlot = Displayimage(FFTPhaseNormalized);

}

public void InverseFFT() {

//Initializing Fourier Transform Array int i, j;

//Calling Forward Fourier Transform Output = new COMPLEX[nx, ny];

Output = FFT2D(Fourier, nx, ny, -1); Obj = null;

(32)

}

Obj = Displayimage(GreyImage); return;

}

public void InverseFFT(COMPLEX[,] Fourier) {

//Initializing Fourier Transform Array int i, j;

Output = new COMPLEX[nx, ny];

Output = FFT2D(Fourier, nx, ny, -1); for (i = 0; i <= Width - 1; i++) for (j = 0; j <= Height - 1; j++) {

GreyImage[i, j] = (int)Output[i, j].Magnitude(); }

Obj = Displayimage(GreyImage); return;

}

public COMPLEX[,] FFT2D(COMPLEX[,] c, int nx, int ny, int dir)

{

int i, j;

int m;//Power of 2 for current number of points double[] real;

double[] imag;

COMPLEX[,] output;//=new COMPLEX [nx,ny]; output = c; // Copying Array

// Transform the Rows real = new double[nx]; imag = new double[nx]; for (j = 0; j < ny; j++) {

for (i = 0; i < nx; i++) {

real[i] = c[i, j].real; imag[i] = c[i, j].imag; }

m = (int)Math.Log((double)nx, 2); FFT1D(dir, m, ref real, ref imag); for (i = 0; i < nx; i++)

{

output[i, j].real = real[i]; output[i, j].imag = imag[i]; }

}

(33)

imag = new double[ny]; for (i = 0; i < nx; i++) {

for (j = 0; j < ny; j++) {

real[j] = output[i, j].real; imag[j] = output[i, j].imag; }

// Calling 1D FFT Function for Columns m = (int)Math.Log((double)ny, 2); FFT1D(dir, m, ref real, ref imag); for (j = 0; j < ny; j++)

{

output[i, j].real = real[j]; output[i, j].imag = imag[j]; }

}

// return(true); return (output); }

private void FFT1D(int dir, int m, ref double[] x, ref double[] y)

{

long nn, i, i1, j, k, i2, l, l1, l2; double c1, c2, tx, ty, t1, t2, u1, u2, z; /* Calculate the number of points */ nn = 1;

for (i = 0; i < m; i++) nn *= 2;

/* Do the bit reversal */ i2 = nn >> 1;

j = 0;

for (i = 0; i < nn - 1; i++) {

if (i < j) {

tx = x[i]; ty = y[i]; x[i] = x[j]; y[i] = y[j]; x[j] = tx; y[j] = ty; }

k = i2;

while (k <= j) {

j -= k; k >>= 1; }

j += k; }

/* Compute the FFT */ c1 = -1.0;

(34)

for (l = 0; l < m; l++) {

l1 = l2; l2 <<= 1; u1 = 1.0; u2 = 0.0;

for (j = 0; j < l1; j++) {

for (i = j; i < nn; i += l2) {

i1 = i + l1;

t1 = u1 * x[i1] - u2 * y[i1]; t2 = u1 * y[i1] + u2 * x[i1]; x[i1] = x[i] - t1;

y[i1] = y[i] - t2; x[i] += t1;

y[i] += t2; }

z = u1 * c1 - u2 * c2; u2 = u1 * c2 + u2 * c1; u1 = z;

}

c2 = Math.Sqrt((1.0 - c1) / 2.0); if (dir == 1)

c2 = -c2;

c1 = Math.Sqrt((1.0 + c1) / 2.0); }

/* Scaling for forward transform */ if (dir == 1)

{

for (i = 0; i < nn; i++) {

x[i] /= (double)nn; y[i] /= (double)nn; }

}

return; }