public FourierTransform(Complex[,] image)
{
Width = image.GetLength(0);
Height = image.GetLength(1);
GrayscaleImageComplex = image;
GrayscaleImageInteger = ImageDataConverter.ToInteger(image);
}
public Bitmap Apply(Bitmap image, KassWitkinKernel kernel)
{
Complex[,] cImagePadded = ImageDataConverter.ToComplex(image);
Complex[,] cKernelPadded = kernel.ToComplexPadded();
Complex[,] convolved = Convolution.Convolve(cImagePadded, cKernelPadded);
return(ImageDataConverter.ToBitmap(convolved));
}
public FourierTransform(int[,] image)
{
Width = image.GetLength(0);
Height = image.GetLength(1);
ImageBitmap = ImageDataConverter.ToBitmap(image);
GrayscaleImageInteger = image;
GrayscaleImageComplex = ImageDataConverter.ToComplex(GrayscaleImageInteger);
}
public FourierTransform(Bitmap image)
{
ImageBitmap = image;
Width = image.Width;
Height = image.Height;
GrayscaleImageInteger = Grayscale.ToGrayscale2(ImageBitmap);
GrayscaleImageComplex = ImageDataConverter.ToComplex(GrayscaleImageInteger);
}
public PictureBoxForm(Complex[,] image1, Complex[,] image2)
{
InitializeComponent();
Bitmap bitmap1 = ImageDataConverter.ToBitmap(image1);
Bitmap bitmap2 = ImageDataConverter.ToBitmap(image2);
this.pictureBox1.Image = bitmap1 as System.Drawing.Image;
this.pictureBox2.Image = bitmap2 as System.Drawing.Image;
}
/*
* public void Pad(int newWidth, int newHeight)
* {
* double[,] temp = (double[,])Kernel.Clone();
* PaddedKernel = ImagePadder.Pad(temp, newWidth, newHeight);
* }*/
public void Pad(int unpaddedWidth, int unpaddedHeight, int newWidth, int newHeight)
{
cPaddedKernel = new Complex[newWidth, newHeight];
//32x32
Complex[,] unpaddedKernelFrequencyDomain = ImageDataConverter.ToComplex((double[, ])Kernel.Clone());
FourierTransform ftInverse = new FourierTransform();
ftInverse.InverseFFT(FourierShifter.RemoveFFTShift(unpaddedKernelFrequencyDomain));
//32x32
Complex[,] unpaddedKernelTimeDomain = FourierShifter.FFTShift(ftInverse.GrayscaleImageComplex);
int startPointX = (int)Math.Ceiling((double)(newWidth - unpaddedWidth) / (double)2) - 1;
int startPointY = (int)Math.Ceiling((double)(newHeight - unpaddedHeight) / (double)2) - 1;
for (int j = startPointY; j < startPointY + unpaddedHeight; j++)
{
for (int i = startPointX; i < startPointX + unpaddedWidth; i++)
{
cPaddedKernel[i, j] = unpaddedKernelTimeDomain[i - startPointX, j - startPointY];
}
}
/*
* for (int j = 0; j < newHeight; j++)
* {
* for (int i = 0; i < startPointX; i++)
* {
* unpaddedKernelTimeDomain[i, j] = 0;
* }
* for (int i = startPointX + unpaddedWidth; i < newWidth; i++)
* {
* unpaddedKernelTimeDomain[i, j] = 0;
* }
* }
*
* for (int i = startPointX; i < startPointX + unpaddedWidth; i++)
* {
* for (int j = 0; j < startPointY; j++)
* {
* unpaddedKernelTimeDomain[i, j] = 0;
* }
* for (int j = startPointY + unpaddedHeight; j < newHeight; j++)
* {
* unpaddedKernelTimeDomain[i, j] = 0;
* }
* }
**/
FourierTransform ftForward = new FourierTransform(cPaddedKernel); ftForward.ForwardFFT();
//cPaddedKernel = ftForward.FourierImageComplex;
}
private void convolveButton_Click(object sender, EventArgs e)
{
Bitmap paddedLena = inputImagePictureBox.Image as Bitmap;
Bitmap paddedMask = paddedMaskPictureBox.Image as Bitmap;
Complex[,] cLena = ImageDataConverter.ToComplex(paddedLena);
Complex[,] cPaddedMask = ImageDataConverter.ToComplex(paddedMask);
Complex[,] cConvolved = Convolution.Convolve(cLena, cPaddedMask);
Bitmap convolved = ImageDataConverter.ToBitmap(cConvolved);
convolvedImagePictureBox.Image = convolved;
}
public List <Bitmap> Apply(Bitmap bitmap)
{
Kernels = new List <KassWitkinKernel>();
double degrees = FilterAngle;
KassWitkinKernel kernel;
for (int i = 0; i < NoOfFilters; i++)
{
kernel = new KassWitkinKernel();
kernel.Width = KernelDimension;
kernel.Height = KernelDimension;
kernel.CenterX = (kernel.Width) / 2;
kernel.CenterY = (kernel.Height) / 2;
kernel.Du = 2;
kernel.Dv = 2;
kernel.ThetaInRadian = Tools.DegreeToRadian(degrees);
kernel.Compute();
//SleuthEye
kernel.Pad(kernel.Width, kernel.Height, WidthWithPadding, HeightWithPadding);
Kernels.Add(kernel);
degrees += degrees;
}
List <Bitmap> list = new List <Bitmap>();
Bitmap image = (Bitmap)bitmap.Clone();
Complex[,] cImagePadded = ImageDataConverter.ToComplex(image);
FourierTransform ftForImage = new FourierTransform(cImagePadded); ftForImage.ForwardFFT();
Complex[,] fftImage = ftForImage.FourierImageComplex;
foreach (KassWitkinKernel k in Kernels)
{
Complex[,] cKernelPadded = k.ToComplexPadded();
Complex[,] convolved = Convolution.ConvolveInFrequencyDomain(fftImage, cKernelPadded);
Bitmap temp = ImageDataConverter.ToBitmap(convolved);
list.Add(temp);
}
return(list);
}
public void InverseFFT(Complex[,] fftImage)
{
if (FourierImageComplex == null)
{
FourierImageComplex = fftImage;
Width = FourierImageComplex.GetLength(0);
Height = FourierImageComplex.GetLength(1);
}
GrayscaleImageComplex = FourierFunction.FFT2D(FourierImageComplex, Width, Height, -1);
GrayscaleImageInteger = ImageDataConverter.ToInteger(GrayscaleImageComplex);
ImageBitmap = ImageDataConverter.ToBitmap(GrayscaleImageInteger);
}
public static int[,] ToGrayscale2(Bitmap colorBitmap)
{
Bitmap bmp = Grayscale.ToGrayscale(colorBitmap);
return(ImageDataConverter.ToInteger(bmp));
}
public static Bitmap FftPhasePlot(Complex[,] fftImage)
{
int[,] FourierPhaseNormalizedInteger = FourierNormalizer.Normalize(fftImage, NormalizeType.Phase);
return(ImageDataConverter.ToBitmap(FourierPhaseNormalizedInteger));
}
public Complex[,] ToComplex()
{
return(ImageDataConverter.ToComplex(Kernel));
}
public Bitmap ToBitmapPadded()
{
return(ImageDataConverter.ToBitmap(PaddedKernel));
}
//public Complex[,] ToComplexPadded()
//{
// return ImageDataConverter.ToComplex(PaddedKernel);
//}
#endregion
public Bitmap ToBitmap()
{
return(ImageDataConverter.ToBitmap(Kernel));
}
public static Bitmap ToBitmap(Complex[,] image)
{
return(ImageDataConverter.ToBitmap(ImageDataConverter.ToInteger(image)));
}
public static Complex[,] ToComplex(Bitmap image)
{
return(ImageDataConverter.ToComplex(ImageDataConverter.ToInteger(image)));
}
