private void button7_Click(object sender, EventArgs e)
{
float[,] filtreHomemade =
{
{ (float)numericUpDown1.Value, (float)numericUpDown2.Value, (float)numericUpDown3.Value },
{ (float)numericUpDown6.Value, (float)numericUpDown5.Value, (float)numericUpDown4.Value },
{ (float)numericUpDown9.Value, (float)numericUpDown8.Value, (float)numericUpDown7.Value }
};
Mat img = CvInvoke.Imread(FilePath, ImreadModes.AnyColor);
Mat ImgDest = new Mat();
string ImgDestString = textBox1.Text;
Point point = new Point(0, 0);
Size size = new Size(9, 9);
if (!img.IsEmpty)
{
ConvolutionKernelF kernel = new ConvolutionKernelF(filtreHomemade);
ImgDest = img;
CvInvoke.Filter2D(img, ImgDest, kernel, point);
if (ImgDestString != "")
{
CvInvoke.Imwrite(ImgDestString, ImgDest);
pictureBox2.ImageLocation = textBox1.Text;
}
else
{
CvInvoke.Imwrite("NoName.jpg", ImgDest);
pictureBox2.ImageLocation = "NoName.jpg";
}
CvInvoke.WaitKey(0);
}
}
///<summary>
///Performs a convolution using the specific <paramref name="kernel"/>
///</summary>
///<param name="kernel">The convolution kernel</param>
///<returns>The result of the convolution</returns>
public OclImage <TColor, Byte> Convolution(ConvolutionKernelF kernel)
{
OclImage <TColor, Byte> result = new OclImage <TColor, Byte>(Size);
OclInvoke.Filter2D(_ptr, result, kernel, kernel.Center, CvEnum.BORDER_TYPE.REFLECT101);
return(result);
}
///<summary>
///Performs a convolution using the specific <paramref name="kernel"/>
///</summary>
///<param name="kernel">The convolution kernel</param>
///<returns>The result of the convolution</returns>
public GpuImage <TColor, Single> Convolution(ConvolutionKernelF kernel)
{
GpuImage <TColor, Single> result = new GpuImage <TColor, float>(Size);
GpuInvoke.Filter2D(_ptr, result, kernel, kernel.Center);
return(result);
}
static public IFilter New()
{
float[,] kernal_array = { { 0, -1, 0 }, { -1, 5, -1 }, { 0, -1, 0 } };
var convol_colution = new ConvolutionKernelF(kernal_array);
return(new Test(convol_colution));
}
private void Execute_Click(object sender, EventArgs e)
{
if (image == null)
{
MessageBox.Show("You didn't pick an image!");
return;
}
float[,] k = Filter3x3();
if (RadioButton5X5.Checked)
{
k = Filter5x5();
}
if (RadioButton7X7.Checked)
{
Filter7x7();
}
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
Image <Gray, byte> imageFiltered = new Image <Gray, byte>(image.Width, image.Height);
Image <Gray, byte> imageGray = image.Convert <Gray, byte>();
CvInvoke.Filter2D(imageGray, imageFiltered, kernel, new Point(-1, -1), 0, borderType);
MasksPictureBox.Image = imageFiltered.ToBitmap();
Tools.Histogram(MasksChart, (Bitmap)MasksPictureBox.Image);
}
public GpuImage <TColor, Single> Convolution(ConvolutionKernelF kernel, Stream stream)
{
GpuImage <TColor, Single> result = new GpuImage <TColor, float>(Size);
GpuInvoke.Filter2D(_ptr, result, kernel, kernel.Center, CvEnum.BORDER_TYPE.REFLECT101, stream);
return(result);
}
private void button6_Click(object sender, EventArgs e)
{
Mat img = CvInvoke.Imread(FilePath, ImreadModes.AnyColor);
Mat ImgDest = new Mat();
string ImgDestString = textBox1.Text;
Point point = new Point(0, 0);
Size size = new Size(9, 9);
if (!img.IsEmpty)
{
ConvolutionKernelF kernel = new ConvolutionKernelF(filtreCustom);
ImgDest = img;
CvInvoke.Filter2D(img, ImgDest, kernel, point);
if (ImgDestString != "")
{
CvInvoke.Imwrite(ImgDestString, ImgDest);
pictureBox2.ImageLocation = textBox1.Text;
}
else
{
CvInvoke.Imwrite("NoName.jpg", ImgDest);
pictureBox2.ImageLocation = "NoName.jpg";
}
CvInvoke.WaitKey(0);
}
}
public void TestConvolutionAndLaplace()
{
if (CudaInvoke.HasCuda)
{
Image <Gray, Byte> image = new Image <Gray, byte>(300, 400);
image.SetRandUniform(new MCvScalar(0.0), new MCvScalar(255.0));
float[,] k = { { 0, 1, 0 },
{ 1, -4, 1 },
{ 0, 1, 0 } };
using (ConvolutionKernelF kernel = new ConvolutionKernelF(k))
using (Stream s = new Stream())
using (GpuMat cudaImg = new GpuMat(image))
using (GpuMat cudaLaplace = new GpuMat())
using (CudaLinearFilter cudaLinear = new CudaLinearFilter(DepthType.Cv8U, 1, DepthType.Cv8U, 1, kernel, kernel.Center))
using (GpuMat cudaConv = new GpuMat())
using (CudaLaplacianFilter laplacian = new CudaLaplacianFilter(DepthType.Cv8U, 1, DepthType.Cv8U, 1, 1, 1.0))
{
cudaLinear.Apply(cudaImg, cudaConv, s);
laplacian.Apply(cudaImg, cudaLaplace, s);
s.WaitForCompletion();
Assert.IsTrue(cudaLaplace.Equals(cudaConv));
}
}
}
private void btnWord_Click(object sender, EventArgs e)
{
float[,] matrixKernel = new float[3, 3] {
{ 0, -1, 0 },
{ -1, 5, -1 },
{ 0, -1, 0 }
};
ConvolutionKernelF kernel = new ConvolutionKernelF(matrixKernel);
Image <Gray, float> result = img.Convert <Gray, float>().Convolution(kernel);
Image <Gray, Byte> GRAYResult = result.Convert <Gray, Byte>();
imageBox2.Image = GRAYResult;
//file to d:
StreamWriter sw = File.CreateText(datapath);
for (int y = 0; y < GRAYResult.Cols; y++)
{
for (int x = 0; x < GRAYResult.Rows; x++)
{
string pixel = GRAYResult.Data[x, y, 0].ToString() + ";";
sw.Write(pixel);
}
}
sw.Close();
}
public void TestConvolutionAndLaplace()
{
Mat image = new Mat(new Size(300, 400), DepthType.Cv8U, 1);
CvInvoke.Randu(image, new MCvScalar(0.0), new MCvScalar(255.0));
Mat laplacian = new Mat();
CvInvoke.Laplacian(image, laplacian, DepthType.Cv8U);
float[,] k = { { 0, 1, 0 },
{ 1, -4, 1 },
{ 0, 1, 0 } };
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
Mat convoluted = new Mat(image.Size, DepthType.Cv8U, 1);
CvInvoke.Filter2D(image, convoluted, kernel, kernel.Center);
Mat absDiff = new Mat();
CvInvoke.AbsDiff(laplacian, convoluted, absDiff);
int nonZeroPixelCount = CvInvoke.CountNonZero(absDiff);
EmguAssert.IsTrue(nonZeroPixelCount == 0);
//Emgu.CV.UI.ImageViewer.Show(absDiff);
}
/// <summary>
/// Процедура вызывается постоянно и отвечает за обработку кадров
/// </summary>
/// <param name="sender"></param>
/// <param name="arg"></param>
private void ProcessFrame(object sender, EventArgs arg)
{
DateTime DTTest = DateTime.Now; //Время сейчас
if (KernelOfGabor != null) //Если ядро для преобразования Габбора заданно
/////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
{
if ((DateTime.Now - LastFrame).TotalMilliseconds >= 100) // ОГРАНИЧЕНИЕ НА ЧАСТОТУ - поставленно принудительно, чтобы частота не выползада в 30 фпс и всё не висло
{
persec++; //Счётчик ФПСа
LastFrame = DateTime.Now; //Время захвата
Image <Bgr, float> image = _capture.QueryFrame().Convert <Bgr, float>().PyrDown().PyrDown(); //Захватываем, уменьшая изображение в 4 раза по каждой стороне
imageBox4.Image = image.Clone(); //Отобразим на экране
//Сделаем сdёртку с ядром
Point _center = new Point(KernelOfGabor.Rows / 2 + 1, KernelOfGabor.Cols / 2 + 1);
ConvolutionKernelF _kernel;
_kernel = new ConvolutionKernelF(KernelOfGabor, _center);
Image <Bgr, float> _conv = image.Convolution(_kernel);
//Прибавим счётчик
CurrentCapturePosition++;
if (CurrentCapturePosition == LengthOfCapture) //Если заполнили массив - печещёлкиваем счётчик
{
CurrentCapturePosition = 0; //Перещёлкнем счётчик на ноль
IsStackFull = true; //Объявим о начале работы
started = true;
this.Text = "In Work";
}
//Загрузим изображения в массивы
if (Ic[CurrentCapturePosition] == null)
{
Ic[CurrentCapturePosition] = new ImageCaptured(_conv);
Irealpic[CurrentCapturePosition] = new ImageCaptured(image);
}
else
{
lock (Ic[CurrentCapturePosition].locker)
{
Ic[CurrentCapturePosition].I = _conv.Clone();
lock (Irealpic[CurrentCapturePosition].locker)
{
Irealpic[CurrentCapturePosition].I = image.Clone();
}
Ic[CurrentCapturePosition].DT = DateTime.Now;
}
}
if ((started) && (!done))
{
done = true;
}
}
}
label2.Text = (DateTime.Now - DTTest).TotalMilliseconds.ToString(); //Счётчик времени исполнения процедуры
}
private void button8_Click(object sender, EventArgs e)
{
Random rnd = new Random();
float Nombre1 = rnd.Next(-20, 20);
float Nombre2 = rnd.Next(-20, 20);
float Nombre3 = rnd.Next(-20, 20);
float Nombre4 = rnd.Next(-20, 20);
float Nombre5 = rnd.Next(-20, 20);
float Nombre6 = rnd.Next(-20, 20);
float Nombre7 = rnd.Next(-20, 20);
float Nombre8 = rnd.Next(-20, 20);
float Nombre9 = rnd.Next(-20, 20);
numericUpDown1.Value = (decimal)Nombre1;
numericUpDown2.Value = (decimal)Nombre2;
numericUpDown3.Value = (decimal)Nombre3;
numericUpDown4.Value = (decimal)Nombre6;
numericUpDown5.Value = (decimal)Nombre5;
numericUpDown6.Value = (decimal)Nombre4;
numericUpDown7.Value = (decimal)Nombre9;
numericUpDown8.Value = (decimal)Nombre8;
numericUpDown9.Value = (decimal)Nombre7;
float[,] filtreRandom =
{
{ Nombre1, Nombre2, Nombre3 },
{ Nombre4, Nombre5, Nombre6 },
{ Nombre7, Nombre8, Nombre9 }
};
Mat img = CvInvoke.Imread(FilePath, ImreadModes.AnyColor);
Mat ImgDest = new Mat();
string ImgDestString = textBox1.Text;
Point point = new Point(0, 0);
Size size = new Size(9, 9);
if (!img.IsEmpty)
{
ConvolutionKernelF kernel = new ConvolutionKernelF(filtreRandom);
ImgDest = img;
CvInvoke.Filter2D(img, ImgDest, kernel, point);
if (ImgDestString != "")
{
CvInvoke.Imwrite(ImgDestString, ImgDest);
pictureBox2.ImageLocation = textBox1.Text;
}
else
{
CvInvoke.Imwrite("NoName.jpg", ImgDest);
pictureBox2.ImageLocation = "NoName.jpg";
}
CvInvoke.WaitKey(0);
}
}
///<summary>
///Performs a convolution using the specific <paramref name="kernel"/>
///</summary>
///<param name="kernel">The convolution kernel</param>
/// <param name="stream">Use a Stream to call the function asynchronously (non-blocking) or null to call the function synchronously (blocking).</param>
///<returns>The result of the convolution</returns>
public GpuImage <TColor, TDepth> Convolution(ConvolutionKernelF kernel, Stream stream)
{
GpuImage <TColor, TDepth> result = new GpuImage <TColor, TDepth>(Size);
using (GpuLinearFilter <TColor, TDepth> linearFilter = new GpuLinearFilter <TColor, TDepth>(kernel, kernel.Center, CvEnum.BORDER_TYPE.REFLECT101, new MCvScalar()))
{
linearFilter.Apply(this, result, stream);
}
return(result);
}
// не работает, дебаг
public static Image <Gray, Byte> LineBasedDetection(Image <Gray, Byte> inputImg)
{
Image <Gray, Byte> smoothedImg = inputImg.SmoothMedian(3);
//CvInvoke.CLAHE(smoothedImg, 40, new System.Drawing.Size(16, 16), smoothedImg);
CvInvoke.BilateralFilter(inputImg.SmoothMedian(3), smoothedImg, 50, 140, -1);
smoothedImg = smoothedImg.ThresholdToZero(new Gray(30));
#region Kernels and stuff
float[,] TopKernelMatrix = new float[, ] {
{ 0, -1, 0 },
{ 0, 0, 0 },
{ 0, 1, 0, }
};
float[,] BottomKernelMatrix = new float[, ] {
{ 0, 1, 0 },
{ 0, 0, 0 },
{ 0, -1, 0, }
};
float[,] LeftKernelMatrix = new float[, ] {
{ 0, 0, 0 },
{ 1, 0, -1 },
{ 0, 0, 0, }
};
float[,] RightKernelMatrix = new float[, ] {
{ 0, 0, 0 },
{ -1, 0, 1 },
{ 0, 0, 0, }
};
ConvolutionKernelF TopKernel = new ConvolutionKernelF(TopKernelMatrix);
ConvolutionKernelF BottomKernel = new ConvolutionKernelF(BottomKernelMatrix);
ConvolutionKernelF LeftKernel = new ConvolutionKernelF(LeftKernelMatrix);
ConvolutionKernelF RightKernel = new ConvolutionKernelF(RightKernelMatrix);
#endregion
#region Craft top / bottom / left and right images with borders
Image <Gray, Byte> TopImg = new Image <Gray, byte>(inputImg.Size);
Image <Gray, Byte> BottomImg = new Image <Gray, byte>(inputImg.Size);
Image <Gray, Byte> LeftImg = new Image <Gray, byte>(inputImg.Size);
Image <Gray, Byte> RightImg = new Image <Gray, byte>(inputImg.Size);
CvInvoke.Filter2D(smoothedImg, TopImg, TopKernel, new Point(1, 1));
CvInvoke.Filter2D(smoothedImg, BottomImg, BottomKernel, new Point(1, 1));
CvInvoke.Filter2D(smoothedImg, LeftImg, LeftKernel, new Point(1, 1));
CvInvoke.Filter2D(smoothedImg, RightImg, RightKernel, new Point(1, 1));
TopImg = TopImg.ThresholdBinary(new Gray(15), new Gray(255));
BottomImg = BottomImg.ThresholdBinary(new Gray(15), new Gray(255));
LeftImg = LeftImg.ThresholdBinary(new Gray(15), new Gray(255));
RightImg = RightImg.ThresholdBinary(new Gray(15), new Gray(255));
#endregion
# region Находим контуры для всех 4х изображений
private void PrewittCalc(float[,] matrix)
{
ConvolutionKernelF kernel = new ConvolutionKernelF(matrix);
var img = ((Bitmap)pictureList[tabControl.SelectedIndex].Image).ToImage <Bgr, byte>();
var imgDst = new Image <Bgr, byte>(pictureList[tabControl.SelectedIndex].Image.Width,
pictureList[tabControl.SelectedIndex].Image.Height, new Bgr(0, 0, 0));
Emgu.CV.CvInvoke.Filter2D(img, imgDst, kernel, new Point(-1, 1), 0, borderType: Emgu.CV.CvEnum.BorderType.Replicate);
pictureList[tabControl.SelectedIndex].Image = imgDst.ToBitmap();
GC.Collect();
}
private void WLiniowePreset3_Click(object sender, EventArgs e)
{
float[,] matrix = { { 1, -2, 1 }, { -2, 4, -2 }, { 1, -2, 1 } };
ConvolutionKernelF kernel = new ConvolutionKernelF(matrix);
var img = ((Bitmap)PictureList[tabControl1.SelectedIndex].Image).ToImage <Bgr, byte>();
var imgDst = new Image <Bgr, byte>(PictureList[tabControl1.SelectedIndex].Image.Width,
PictureList[tabControl1.SelectedIndex].Image.Height, new Bgr(0, 0, 0));
Emgu.CV.CvInvoke.Filter2D(img, imgDst, kernel, new Point(-1, -1), 0, borderType: Emgu.CV.CvEnum.BorderType.Replicate);
PictureList[tabControl1.SelectedIndex].Image = imgDst.ToBitmap();
}
private Image <Bgr, byte> Sepia(Image <Bgr, byte> image)
{
float[,] array = { { 0.272f, 0.534f, 0.131f }, { 0.349f, 0.686f, 0.168f }, { 0.393f, 0.769f, 0.189f } };
Image <Bgr, byte> img = image.Copy();
ConvolutionKernelF kernel = new ConvolutionKernelF(array);
CvInvoke.Transform(img.Mat, img.Mat, kernel);
return(img);
}
public static Image <Gray, float> Sharpen(Image <Gray, Byte> image)
{
float[,] k = { { 0, 1, 0 },
{ 1, -4, 1 },
{ 0, 1, 0 } };
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
image.SetRandUniform(new MCvScalar(0.0), new MCvScalar(255.0));
Image <Gray, float> laplace = image.Laplace(1);
Image <Gray, float> output = image * kernel;
return(output);
}
private ImageData Operation(ImageForm_Service service, List <int> args)
{
if (args == null)
{
return(null);
}
if (args.Count < 1)
{
return(null);
}
int kSize = args[0];
float[,] k = new float[kSize, kSize];
int c = 0;
for (int i = 1; i < args.Count;)
{
int r = 0;
for ( ; r < kSize; ++r, ++i)
{
k[c, r] = args[i];
}
++c;
}
try
{
Image <Bgra, byte> image = new Image <Bgra, byte>(service.data.LastData().Bitmap);
Image <Gray, byte> gray = image.Convert <Gray, byte>();
//Image<Gray, Byte> image = new Image<Gray, byte>(300, 400);
//gray.SetRandUniform(new MCvScalar(0.0), new MCvScalar(255.0)); // <<<<<<<<<<< Ciekawe
//int apertureSize = 11;
//Image<Gray, float> laplace = gray.Laplace(apertureSize);
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
Image <Gray, float> convoluted = gray * kernel;
//Image<Bgra, float> convoluted = image * kernel;
return(new ImageData(convoluted.Bitmap, service.data.LastData().ID));
}
catch
{
return(null);
}
}
public static Bitmap Filter2D(Bitmap bmp, float[,] mask)
{
string file1 = Utility.SaveBmpTmp(bmp);
Image <Bgr, float> img = new Image <Bgr, float>(file1),
dst = new Image <Bgr, float>(img.Size);
ConvolutionKernelF kernel = new ConvolutionKernelF(mask);
CvInvoke.Filter2D(img, dst, kernel, new Point(-1, -1));
dst.Save(file1);
Bitmap tmpBmp = Utility.BmpFromFile(file1);
File.Delete(file1);
return(tmpBmp);
}
public ConvolutionKernelF GetEmguKernel()
{
var emguKernel = new ConvolutionKernelF(this.kernelSize, this.kernelSize);
for (int i = 0; i < this.kernelSize; i++)
{
for (int j = 0; j < this.kernelSize; j++)
{
emguKernel.Data[i, j] = this.data[i, j];
}
}
return(emguKernel);
}
private void button1_Click(object sender, EventArgs e)
{
float[,] kernel;
Image <Gray, float> _img = img;
var grayImg = img.Convert <Gray, float>();
kernel = mask1;
ConvolutionKernelF ker = new ConvolutionKernelF(kernel);
Image <Gray, float> convoluted = grayImg * ker;
form.SetImage(new Image <Bgr, byte>(convoluted.Bitmap));
form.Refresh();
}
private void button4_Click(object sender, EventArgs e)
{
float[,] kernel;
Image <Gray, float> _img = img;
var grayImg = img.Convert <Gray, float>();
kernel = GetMatrixByKValue((int)numericUpDown1.Value);
ConvolutionKernelF ker = new ConvolutionKernelF(kernel);
Image <Gray, float> convoluted = grayImg * ker;
form.SetImage(new Image <Bgr, byte>(convoluted.Bitmap));
form.Refresh();
}
private Image <Gray, float> OrientedHighPass(Image <Gray, byte> image)
{
Image <Gray, float> filtered = new Image <Gray, float>(image.Size);
Image <Gray, float> final = new Image <Gray, float>(image.Size);
// import parameters
int smoothOpSize = 1;
int filterLength = 22;
int angleStep = 1;
// construct the kernel
float[,,] k3 = new float[1, 5, 1]
{
{ { -1 }, { -1 }, { 4 }, { -1 }, { -1 } },
};
Image <Gray, float> kRow = new Image <Gray, float>(k3);
Image <Gray, float> kImageOriginal = kRow;
for (int l = 0; l < filterLength - 1; ++l)
{
kImageOriginal = kImageOriginal.ConcateVertical(kRow);
}
// first step, smooth image
image._SmoothGaussian(smoothOpSize);
for (int angle = 0; angle < 180; angle += angleStep)
{
// Create convolution kernel
Image <Gray, float> kImage = kImageOriginal.Rotate(angle, new Gray(0), false);
// make sure the average of the kernel stays zero
kImage = kImage - (kImage.GetSum().Intensity / (kImage.Width * kImage.Height));
float[,] k = new float[kImage.Height, kImage.Width];
Buffer.BlockCopy(kImage.Data, 0, k, 0, k.Length * sizeof(float));
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
filtered = image.Convolution(kernel);
final = filtered.Max(final);
}
return(final);
}
private void BuildConvolution()
{
int kernelHeight = 1;
int kernelWidth = 32;
float kernelTotalWeight = 0;
float kernelSize = kernelWidth * kernelHeight;
float[,] kernelValues = new float[kernelHeight, kernelWidth];
for (int i = 0; i < kernelHeight; i++)
{
for (int j = 0; j < kernelWidth; j++)
{
float weight = 0f;
int distFromCentre = Math.Abs(j - (kernelWidth / 2 - 1));
if (distFromCentre < 3)
{
weight = Math.Abs(distFromCentre) * 20;
}
else if (distFromCentre < 10)
{
weight = 0;
}
else
{
weight = -Math.Abs(distFromCentre);
}
kernelValues[i, j] = weight;
kernelTotalWeight += weight;
}
}
for (int i = 0; i < kernelHeight; i++)
{
for (int j = 0; j < kernelWidth; j++)
{
kernelValues[i, j] = kernelValues[i, j] / Math.Abs(kernelTotalWeight);
}
}
m_KernelPole = new ConvolutionKernelF(kernelValues);
}
private void btnClick_Click(object sender, EventArgs e)
{
if (textBox1.Text == "" || textBox2.Text == "" || textBox3.Text == "" || textBox4.Text == "" || textBox5.Text == "" ||
textBox6.Text == "" || textBox7.Text == "" || textBox8.Text == "" || textBox9.Text == "")
{
ErrorForm errorForm = new ErrorForm("Macierz nie została wypełniona w całości!");
return;
}
float[,] k = new float[, ] {
{ float.Parse(textBox1.Text, CultureInfo.InvariantCulture.NumberFormat), float.Parse(textBox2.Text, CultureInfo.InvariantCulture.NumberFormat), float.Parse(textBox3.Text, CultureInfo.InvariantCulture.NumberFormat) },
{ float.Parse(textBox4.Text, CultureInfo.InvariantCulture.NumberFormat), float.Parse(textBox5.Text, CultureInfo.InvariantCulture.NumberFormat), float.Parse(textBox6.Text, CultureInfo.InvariantCulture.NumberFormat) },
{ float.Parse(textBox7.Text, CultureInfo.InvariantCulture.NumberFormat), float.Parse(textBox8.Text, CultureInfo.InvariantCulture.NumberFormat), float.Parse(textBox9.Text, CultureInfo.InvariantCulture.NumberFormat) }
};
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
var img = ((Bitmap)pictureList[tabControl.SelectedIndex].Image).ToImage <Bgr, byte>();
var imgDst = new Image <Bgr, byte>(pictureList[tabControl.SelectedIndex].Image.Width,
pictureList[tabControl.SelectedIndex].Image.Height, new Bgr(0, 0, 0));
Emgu.CV.CvInvoke.Filter2D(img, imgDst, kernel, new Point(-1, -1), 0, borderType: Emgu.CV.CvEnum.BorderType.Replicate);
pictureList[tabControl.SelectedIndex].Image = imgDst.ToBitmap();
}
//фильтр Прюитта
private Image <Bgr, byte> Prewitt(Image <Bgr, byte> img, int aperture)
{
// двумерные массивы для инициализации ядер оператора Прюитта
float[,] arrayX = new float[, ] {
{ -1, 0, 1 }, { -1, 0, 1 }, { -1, 0, 1 },
};
float[,] arrayY = new float[, ] {
{ -1, -1, -1 }, { 0, 0, 0 }, { 1, 1, 1 }
};
// горизонтальное ядро
ConvolutionKernelF kernelX = new ConvolutionKernelF(arrayX);
// пертикальное ядро
ConvolutionKernelF kernelY = new ConvolutionKernelF(arrayY);
// Получаем ч/б изображение
Image <Gray, byte> grayImage = new Image <Gray, byte>(img.Bitmap);
// Изображения для размытия по гауссу
Image <Gray, float> gauss = new Image <Gray, float>(img.Size);
// результирующее изображение
Image <Bgr, byte> finalImage = new Image <Bgr, byte>(img.Size);
//применяем фильтр гаусса с заданной апертурой
CvInvoke.GaussianBlur(grayImage.Mat, gauss.Mat, new Size(aperture, aperture), 0);
// применяем ядра к полученному размытому изображению
Image <Gray, float> imageX = gauss * kernelY;
Image <Gray, float> imageY = gauss * kernelX;
// складываем X и Y составляющую изображения
finalImage = (imageX + imageY).AbsDiff(new Gray(0.0)).Convert <Bgr, byte>();
// очищаем память
imageX.Dispose();
imageY.Dispose();
gauss.Dispose();
grayImage.Dispose();
// возвращаем изображение
return(finalImage);
}
static Image <Gray, Byte> reducenoise(Image <Gray, Byte> image)
{
Int32 biperagain = 75;
float mid = 0.7F;
float margin = (1 - mid) / 8;
float[,] matrixKernel = new float[3, 3] {
{ margin, margin, margin },
{ margin, mid, margin },
{ margin, margin, margin }
};
//float[,] matrixKernel = new float[7, 7] { { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F},
// { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F},
// { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F},
// { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F},
// { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F},
// { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F},
// { 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F, 0.02F} };
//float[,] matrixKernel = new float[3, 3] {{ 0,-1, 0 },{-1, 5,-1 },{ 0,-1, 0 }};
ConvolutionKernelF matrix = new ConvolutionKernelF(matrixKernel);
//Image<Bgr, float> result = new Image<Bgr, float>(image.Width, image.Height);
Image <Gray, float> result = new Image <Gray, float>(image.Width, image.Height);
CvInvoke.Filter2D(image, result, matrix, new Point(0, 0));
//Image<Bgr, Byte> BGRResult = result.Convert<Bgr, Byte>();
//Image<Bgr, Byte> BGRResult = result.ConvertScale<byte>(1, 0);
Image <Gray, Byte> BGRResult = result.ConvertScale <byte>(1, 0);
Image <Gray, Byte> BGRResult2 = grayturnbinary(BGRResult, biperagain);
return(BGRResult2);
}
private void button1_Click(object sender, EventArgs e)
{
float[,] kernel;
Image <Gray, float> B = img[2];
Image <Gray, float> G = img[1];
Image <Gray, float> R = img[0];
if (radioButton1.Checked)
{
kernel = mask1;
}
else if (radioButton2.Checked)
{
kernel = mask2;
}
else
{
kernel = mask3;
}
ConvolutionKernelF ker = new ConvolutionKernelF(kernel);
Image <Gray, float> convolutedR = R * ker;
Image <Gray, float> convolutedG = G * ker;
Image <Gray, float> convolutedB = B * ker;
Image <Bgr, float> afterSharpening = img;
afterSharpening[0] = convolutedR;
afterSharpening[1] = convolutedG;
afterSharpening[2] = convolutedB;
form.SetImage(new Image <Bgr, byte>(afterSharpening.Bitmap));
form.Refresh();
}
private void button3_Click(object sender, EventArgs e)
{
int W = Train_I.Width;
int H = Train_I.Height;
Image<Gray, Double> gaborResult_R = new Image<Gray, Double>(W, H);
double[, ,] gaborResult_R2 = new double[m, n, 1];
float[] gF_R_One_back = new float[m*n];
float[,] gF_R_back = new float[m, n];
double[,] gaborResult_R3 = new double[H, W];
double[] gaborResult_R3_One = new double[H * W];
double[,] gaborResult_R_Mat = new double[W * H, 40];
Image<Gray, Double> gaborResult_I = new Image<Gray, Double>(W, H);
double[, ,] gaborResult_I2 = new double[m, n, 1];
float[] gF_I_One_back = new float[m * n];
float[,] gF_I_back = new float[m, n];
double[,] gaborResult_I3 = new double[H, W];
double[] gaborResult_I3_One = new double[H * W];
double[,] gaborResult_I_Mat = new double[W * H, 40];
for(int p = 0; p < u*v ; p++)
{
// gF_R_One_back = PickUpFilterFloat(gF_R_Mat, p);
gF_R_back = OneToTwoFloat(gF_R_One_back);
ConvolutionKernelF matrix_R = new ConvolutionKernelF(gF_R_back);
CvInvoke.cvFilter2D(Train_I, gaborResult_R, matrix_R, new Point(0, 0));
gaborResult_R2 = gaborResult_R.Data;
gaborResult_R3 = ArrayDownDim(gaborResult_R2);
gaborResult_R3_One = PickUpResultDouble(gaborResult_R3,p);
// gF_I_One_back = PickUpFilterFloat(gF_I_Mat, p);
gF_I_back = OneToTwoFloat(gF_I_One_back);
ConvolutionKernelF matrix_I = new ConvolutionKernelF(gF_I_back);
CvInvoke.cvFilter2D(Train_I, gaborResult_I, matrix_I, new Point(0, 0));
gaborResult_I2 = gaborResult_I.Data;
gaborResult_I3 = ArrayDownDim(gaborResult_I2);
gaborResult_I3_One = PickUpResultDouble(gaborResult_I3,p);
for (int q = 0; q < H ; q++)
{
//System.Console.WriteLine(" q= " + q);
gaborResult_R_Mat[ q , p] = gaborResult_R3_One[q];
gaborResult_I_Mat[ q , p] = gaborResult_I3_One[q];
// System.Console.WriteLine(" gaborResult_R_Mat = " + gaborResult_I_Mat[q, p]);
}
}
int aa = 100;
System.Console.WriteLine(" j = " + aa);
}
private void button1_Click(object sender, EventArgs e)
{
if (op.ShowDialog() == DialogResult.OK)
{
//แปลงภาพเป็น สีเทา
image1 = new Image <Bgr, byte>(op.FileName);
image1 = image1.Resize(1200, 800, Emgu.CV.CvEnum.Inter.Linear, true);
Image <Gray, byte> Gray = image1.Convert <Gray, byte>();
//----------------------------------------------
//เบลอภาพด้วย SmoothGaussian
Gray = Gray.SmoothGaussian(9);
//ทำการEqualize
Gray._EqualizeHist();
imageBox2.Image = Gray;
//---------------------------------------------
//------
// การทำBinarization เป็นภาพแบบ ไบนารี่
Binarization = new Image <Gray, byte>(Gray.Width, Gray.Height, new Gray(0));
//เป็นการทำ Otsu Threshold
CvInvoke.Threshold(Gray, Binarization, 0, 255, Emgu.CV.CvEnum.ThresholdType.Otsu | Emgu.CV.CvEnum.ThresholdType.Binary);
//ในlaw บอกว่าต้องใช่Otsu ร่วมกับ Binary ด้วย
imageBox3.Image = Binarization;
histogramBox3.ClearHistogram();
histogramBox3.GenerateHistograms(Gray, 256);
histogramBox3.Refresh();
//---------------------------------------------------------
// หาขอบภาพด้วย canny edge detection
cny = Binarization.Canny(180, 120);
//-----------------การขยายภาพDilate----------------
cny._Dilate(3);
// -----ทำการConvolution ภาพ
ConvolutionKernelF convolutionKernelF = new ConvolutionKernelF(3, 3);
cny.Convolution(convolutionKernelF);
imageBox1.Image = cny;
//---------------------วาดภาพ ---------------------------------
//Call HoughCircles (Canny included)
CircleF[] circleFs = cny.HoughCircles(
new Gray(180), //cannyThreshold
new Gray(450), //accumulatorThreshold
6.0, //dp
15.0, //minDist
5, //minRadius
0 //maxRadius
)[0];
// Draw circles
int outputva = 0; //ตัวแปรนับเหรียญ
Image <Bgr, Byte> imageCircles = new Image <Bgr, byte>(cny.Size);
foreach (CircleF circle in circleFs)
{
imageCircles.Draw(circle, new Bgr(Color.Red), 5);
outputva++;
}
//show
imageBox4.Image = imageCircles;
textBox1.Text = outputva.ToString();
}
}
public void TestConvolutionAndLaplace()
{
if (CudaInvoke.HasCuda)
{
Image<Gray, Byte> image = new Image<Gray, byte>(300, 400);
image.SetRandUniform(new MCvScalar(0.0), new MCvScalar(255.0));
float[,] k = { {0, 1, 0},
{1, -4, 1},
{0, 1, 0}};
using (ConvolutionKernelF kernel = new ConvolutionKernelF(k))
using (Stream s = new Stream())
using (GpuMat cudaImg = new GpuMat(image))
using (GpuMat cudaLaplace = new GpuMat())
using (CudaLinearFilter cudaLinear = new CudaLinearFilter(DepthType.Cv8U, 1, DepthType.Cv8U, 1, kernel, kernel.Center))
using (GpuMat cudaConv = new GpuMat())
using (CudaLaplacianFilter laplacian = new CudaLaplacianFilter(DepthType.Cv8U, 1, DepthType.Cv8U, 1, 1, 1.0))
{
cudaLinear.Apply(cudaImg, cudaConv, s);
laplacian.Apply(cudaImg, cudaLaplace, s);
s.WaitForCompletion();
Assert.IsTrue(cudaLaplace.Equals(cudaConv));
}
}
}
} // End of the function 'singleGaborFilter_Imag'
private void button3_Click(object sender, EventArgs e)
{
int W = Train_I.Width;
int H = Train_I.Height;
double[, ,] t = new double[H, W, 1];
double[,] img = new double[H, W];
t = Train_Img.Data;
img = ArrayDownDim(t);
Image<Gray, Double> gaborResult_R = new Image<Gray, Double>(W, H);
Image<Gray, Double> gaborResult_I = new Image<Gray, Double>(W, H);
double[, ,] gaborResult_R2 = new double[m, n, 1];
double[, ,] gaborResult_I2 = new double[m, n, 1];
ConvolutionKernelF matrix_R = new ConvolutionKernelF((float)a);
ConvolutionKernelF matrix_I = new ConvolutionKernelF(gFilterImag);
CvInvoke.cvFilter2D(Train_I, gaborResult_R, matrix_R, new Point(0, 0));
CvInvoke.cvFilter2D(Train_I, gaborResult_I, matrix_I, new Point(0, 0));
gaborResult_R2 = gaborResult_R.Data;
gaborResult_I2 = gaborResult_I.Data;
double[,] gaborResult_R3 = new double[m, n];
double[,] gaborResult_I3 = new double[m, n];
}
private void button2_Click(object sender, EventArgs e)
{
// Image<Gray, float> image;
//Point anchor = new Point(-1, -1);
float[,] kernel = new float[5, 5] {
{ 0, 1, 0 ,1,0 },
{ 1, -4, 1 ,0,1},
{ 0, 1, 0 ,1, 1} ,
{ 1, -4, 1 ,0,1},
{ 0, 1, 0 ,1,0 },
};
double[,] test = new double[3, 3] {
{ 0, 1, 0 },
{ 1, -4, 1 },
{ 0, 1, 0 } ,
};
int u = 3; float v = 5.0F; float j = 1.0F;
int m = 39; int n = 39;
//int m = 2; int n = 2;
const float PI = (float)Math.PI;
float tetav = (j * PI)/(v + 1) ;
float fmax = 0.25F;
float gama = (float)Math.Sqrt(2);
float eta = (float)Math.Sqrt(2);
float fu = (float)(fmax / Math.Pow((Math.Sqrt(2)), u-1));
float alpha = fu / gama;
float beta = fu / eta;
float[,] gFilterReal = new float[m, n];
float[,] gFilterImag = new float[m, n];
////
for (int x = 0; x < m; x++)
{
for (int y = 0; y < n; y++)
{
//double a1 = Math.Cos(tetav);
//double a2 = (x + 1 - (0.5 * (m + 1)));
//double a3 = (y + 1 - (0.5 * (m + 1)));
float xprime = (float)((x + 1 - (0.5 * (m + 1))) * Math.Cos(tetav) + ((y + 1 - (0.5 * (n + 1)))) * Math.Sin(tetav));
float yprime = (float)((-1.0) * ( (x + 1 - (0.5 * (m + 1))) * Math.Sin(tetav) +
(y + 1 - (0.5 * (n + 1))) * Math.Cos(tetav)
)
);
float Con = (float)((Math.Pow(fu, 2)) / (PI * gama * eta));
float Gauss = (float)(Con * Math.Exp(-((Math.Pow(alpha, 2) * Math.Pow(xprime, 2)) +
(Math.Pow(beta, 2) * Math.Pow(yprime, 2))
)
)
);
Complex z = new Complex(Gauss * Math.Cos(2 * PI * fu * xprime), Gauss * Math.Sin(2 * PI * fu * xprime));
gFilterReal[x, y] = (float)z.Real;
gFilterImag[x, y] = (float)z.Imaginary;
}
}
/// debug
//int x = 1;
//int y = 1;
// double a1 = Math.Cos(tetav);
// double a2 = (x + 1 - (0.5 * (m + 1)));
// double a3 = (y + 1 - (0.5 * (m + 1)));
// float xprime = (float)((x + 1 - (0.5 * (m + 1))) * Math.Cos(tetav) + ((y + 1 - (0.5 * (n + 1)))) * Math.Sin(tetav));
// float yprime = (float)((-1.0) * ((x + 1 - (0.5 * (m + 1))) * Math.Sin(tetav) + (y + 1 - (0.5 * (n + 1))) * Math.Cos(tetav)
// )
// );
// float Con = (float)((Math.Pow(fu, 2)) / (PI * gama * eta));
// float Gauss = (float)( Math.Exp(-((Math.Pow(alpha, 2) * Math.Pow(xprime, 2)) +
// (Math.Pow(beta, 2) * Math.Pow(yprime, 2))
// )
// )
// );
// Complex z = new Complex(Con*Gauss * Math.Cos(2 * PI * fu * xprime),Con* Gauss * Math.Sin(2 * PI * fu * xprime));
// gFilterReal[x, y] = (float)z.Real;
// gFilterImag[x, y] = (float)z.Imaginary;
// double yy = Con*Gauss * Math.Sin(2 * PI * fu * xprime);
using (OpenFileDialog ofd = new OpenFileDialog())
{
if (ofd.ShowDialog() == DialogResult.OK)
{
double scale = 0.5;
//Image<Gray, Byte> image = new Image<Gray, byte>(ofd.FileName);
Train_I = new Image<Gray, byte>(ofd.FileName).Resize(scale, Emgu.CV.CvEnum.INTER.CV_INTER_LINEAR); //////原影像
//CvInvoke.cvShowImage("Image<Bgr, Byte>", Train_I);
Train_Img = Train_I.Convert<Gray,double>() ;
int W = Train_I.Width;
int H = Train_I.Height;
double[,,] t = new double[H, W,1];
double[,] img = new double[H, W];
t = Train_Img.Data;
img = ArrayDownDim(t);
Image<Gray, Double> gaborResult_R = new Image<Gray, Double>(W, H);
Image<Gray, Double> gaborResult_I = new Image<Gray, Double>(W, H);
double[,,] gaborResult_R2 = new double[m,n,1];
double[,,] gaborResult_I2 = new double[m, n, 1];
//gFilterReal;
//gFilterImag;
ConvolutionKernelF matrix_R = new ConvolutionKernelF(gFilterReal);
ConvolutionKernelF matrix_I = new ConvolutionKernelF(gFilterImag);
CvInvoke.cvFilter2D(Train_I, gaborResult_R, matrix_R, new Point(0, 0));
CvInvoke.cvFilter2D(Train_I, gaborResult_I, matrix_I, new Point(0, 0));
gaborResult_R2 = gaborResult_R.Data;
gaborResult_I2 = gaborResult_I.Data;
double[,] gaborResult_R3 = new double[m, n];
double[,] gaborResult_I3 = new double[m, n];
//Matrix<double> M = new Matrix<double>(m, n);
//double min, max;
//Point point1, point2;
//M.MinMax(out min, out max, out point1, out point2);
//Image<Bgr, byte> I = new Image<Bgr, byte>(M.Size);
//M.Convert<byte>().CopyTo(I);
//I.Save(@"D:\程式區\output.bmp");
gaborResult_R3 = ArrayDownDim(gaborResult_R2);
gaborResult_I3 = ArrayDownDim(gaborResult_I2);
double[,] gaborAbs = new double[m, n];
double[] gaborAbsDone = new double[m * n];
double[] gaborAbsOne = new double[m * n];
double gaborAbsOneStd, gaborAbsOneMean;
gaborAbs = ComplexAbs(gaborResult_R3, gaborResult_I3);
gaborAbsOne = TwoToOne(gaborAbs);
gaborAbsOneStd = StandardDeviation(gaborAbsOne);
gaborAbsOneMean = Average(gaborAbsOne);
gaborAbsDone = ArrayMultip(ArrayAdd(gaborAbsOne, gaborAbsOneMean), gaborAbsOneStd);
//CvInvoke.cvShowImage("Image<Gray, Byte>", result_I);
/// Excel
string pathFile = @"D:\程式區\gaborResultRealCS05j0F";
//string pathFile = @"D:\程式區\gaborResultRealCS05j1F";
//string pathFile = @"D:\程式區\gaborResultImagCS05j1F";
//string pathFile = @"D:\程式區\gaborAbsCS05j1F";
//string pathFile = @"D:\程式區\gaborAbsOneCS05j1F";
// string pathFile = @"D:\程式區\gFilterR_CS05j1F";
// string pathFile = @"D:\程式區\gFilterI_CS05j1F";
Excel.Application excelApp;
Excel._Workbook wBook;
Excel._Worksheet wSheet;
Excel.Range wRange;
// 開啟一個新的應用程式
excelApp = new Excel.Application();
// 讓Excel文件可見
excelApp.Visible = true;
// 停用警告訊息
excelApp.DisplayAlerts = false;
// 加入新的活頁簿
excelApp.Workbooks.Add(Type.Missing);
// 引用第一個活頁簿
wBook = excelApp.Workbooks[1];
// 設定活頁簿焦點
wBook.Activate();
try
{
// 引用第一個工作表
wSheet = (Excel._Worksheet)wBook.Worksheets[1];
// 命名工作表的名稱
wSheet.Name = "Resize";
// 設定工作表焦點
wSheet.Activate();
//excelApp.Cells[1, 1] =img[0,0];
// 設定第1列資料
// excelApp.Cells[1, 1] = "名稱";
//excelApp.Cells[1, 2] = kernel[1, 1];
for (int q = 0; q < W; q++)
{
for (int p = 0; p < H; p++)
{
//System.Console.WriteLine(p);
// System.Console.WriteLine(q);
//excelApp.Cells[p + 1, q + 1] = gaborAbs[p, q];
// excelApp.Cells[p + 1, q + 1] = gaborResult_R3[p, q];
// excelApp.Cells[p + 1, q + 1] = gaborResult_I3[p, q];
// excelApp.Cells[p + 1, q + 1] = gaborAbs[p, q];
}
}
for (int q = 0; q < n; q++)
{
for (int p = 0; p < m; p++)
{
// excelApp.Cells[p + 1, q + 1] = gFilterReal[p, q];
excelApp.Cells[p + 1, q + 1] = gFilterImag[p, q];
//excelApp.Cells[p + 1, q + 1] = matrix_R[p, q];
//excelApp.Cells[p + 1, q + 1] = matrix_I[p, q];
}
}
//for (int q = 0; q < W*H; q++)
//{
// excelApp.Cells[q+1 , 1] = gaborAbsOne[q];
//}
// 設定第1列顏色
wRange = wSheet.Range[wSheet.Cells[1, 1], wSheet.Cells[1, 2]];
wRange.Select();
wRange.Font.Color = ColorTranslator.ToOle(Color.White);
wRange.Interior.Color = ColorTranslator.ToOle(Color.DimGray);
// 設定第2列資料
//excelApp.Cells[2, 1] = "AA";
//excelApp.Cells[2, 2] = "10";
// 設定第3列資料
//excelApp.Cells[3, 1] = "BB";
//excelApp.Cells[3, 2] = "20";
// 設定第4列資料
//excelApp.Cells[4, 1] = "CC";
//excelApp.Cells[4, 2] = "30";
// 設定第5列資料
//excelApp.Cells[5, 1] = "總計";
// 設定總和公式 =SUM(B2:B4)
// excelApp.Cells[5, 2].Formula = string.Format("=SUM(B{0}:B{1})", 2, 4);
// 設定第5列顏色
wRange = wSheet.Range[wSheet.Cells[5, 1], wSheet.Cells[5, 2]];
wRange.Select();
wRange.Font.Color = ColorTranslator.ToOle(Color.Red);
wRange.Interior.Color = ColorTranslator.ToOle(Color.Yellow);
// 自動調整欄寬
wRange = wSheet.Range[wSheet.Cells[1, 1], wSheet.Cells[5, 2]];
wRange.Select();
wRange.Columns.AutoFit();
try
{
//另存活頁簿
wBook.SaveAs(pathFile, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlNoChange, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
Console.WriteLine("儲存文件於 " + Environment.NewLine + pathFile);
}
catch (Exception ex)
{
Console.WriteLine("儲存檔案出錯，檔案可能正在使用" + Environment.NewLine + ex.Message);
}
}
catch (Exception ex)
{
Console.WriteLine("產生報表時出錯！" + Environment.NewLine + ex.Message);
}
//關閉活頁簿
wBook.Close(false, Type.Missing, Type.Missing);
//關閉Excel
excelApp.Quit();
//釋放Excel資源
System.Runtime.InteropServices.Marshal.ReleaseComObject(excelApp);
wBook = null;
wSheet = null;
wRange = null;
excelApp = null;
GC.Collect();
Console.Read();
/// Excel end
}
}
}
private void BuildConvolution()
{
int kernelHeight = 1;
int kernelWidth = 32;
float kernelTotalWeight = 0;
float kernelSize = kernelWidth * kernelHeight;
float[,] kernelValues = new float[kernelHeight, kernelWidth];
for (int i = 0; i < kernelHeight; i++)
for (int j = 0; j < kernelWidth; j++)
{
float weight = 0f;
int distFromCentre = Math.Abs(j - (kernelWidth / 2 - 1));
if (distFromCentre < 3)
weight = Math.Abs(distFromCentre) * 20;
else if (distFromCentre < 10)
weight = 0;
else
weight = -Math.Abs(distFromCentre);
kernelValues[i, j] = weight;
kernelTotalWeight += weight;
}
for (int i = 0; i < kernelHeight; i++)
for (int j = 0; j < kernelWidth; j++)
{
kernelValues[i, j] = kernelValues[i, j] / Math.Abs(kernelTotalWeight);
}
m_KernelPole = new ConvolutionKernelF(kernelValues);
}
public void TestConvolutionAndLaplace()
{
Image<Gray, Byte> image = new Image<Gray, byte>(300, 400);
image.SetRandUniform(new MCvScalar(0.0), new MCvScalar(255.0));
Image<Gray, float> laplace = image.Laplace(1);
float[,] k = { {0, 1, 0},
{1, -4, 1},
{0, 1, 0}};
ConvolutionKernelF kernel = new ConvolutionKernelF(k);
Image<Gray, float> convoluted = image * kernel;
Image<Gray, float> absDiff = new Image<Gray, float>(convoluted.Size);
CvInvoke.AbsDiff(laplace, convoluted, absDiff);
//Emgu.CV.UI.ImageViewer.Show(absDiff.Convert<Gray, byte>());
EmguAssert.IsTrue(laplace.Equals(convoluted));
/*
try
{
Matrix<float> kernel1D = new Matrix<float>(new float[] { 1.0f, -2.0f, 1.0f });
Image<Gray, float> result = new Image<Gray, float>(image.Width, image.Height);
CvInvoke.cvFilter2D(image, result, kernel1D, new MCvPoint(0, 1));
}
catch (Exception e)
{
throw e;
}*/
}
/// <summary>
/// claculates gradient
/// </summary>
/// <param name="crop">should crop image. (calculate gradient only for center.)</param>
/// <returns>integer that represents gradient value</returns>
public static int calcGradiant(bool crop)
{
Image<Gray, float> imgGradiant = _imageGray.Convert<Gray, float>();
if (crop)
{
Rectangle sizeToCrop = new Rectangle(_imageGray.Cols / 4, _imageGray.Rows / 4, _imageGray.Cols /2, _imageGray.Rows /2);
// Crop face
imgGradiant = _imageGray.Convert<Gray, float>().Copy(sizeToCrop);
// imgGradiant.Save("C:\\img\\crp.jpg");
}
//smooth the image a little bit
imgGradiant.SmoothGaussian(3);
//create filters for differential by X and by Y
float[,] filterY = {{ 1, 1, 1},
{-1,-1,-1}};
float[,] filterX = {{1,-1},
{1,-1},
{1,-1}};
ConvolutionKernelF convFilterY = new ConvolutionKernelF(filterY),
convFilterX = new ConvolutionKernelF(filterX);
Image<Gray, float> diffY = imgGradiant.Convolution(convFilterY);//.Pow(2);
Image<Gray, float> diffX = imgGradiant.Convolution(convFilterX);//.Pow(2);
abs(ref diffX, ref diffY);
// abs(ref diffY);
imgGradiant = diffX.Add(diffY);
/* imgGradiant.Save("C:\\img\\notsharpGradient1.JPG");
////display the image
ImageViewer viewer = new ImageViewer(); //create an image viewer
viewer.Image = imgGradiant;
viewer.Show();//show the image viewer
*/
//calculates the integral of the gradiant image
MCvScalar sum = CvInvoke.cvSum(imgGradiant);
int gradientSum = (int)(sum.v0 / (imgGradiant.Rows * imgGradiant.Cols));
//dealllocate image
if (imgGradiant != null)
{
imgGradiant.Dispose();
}
if (diffY != null)
{
diffY.Dispose();
}
if (diffX != null)
{
diffX.Dispose();
}
imgGradiant = null;
diffX = null;
diffY = null;
GC.Collect();
return gradientSum;
}
public Image<Bgr, byte> GetHighBoostFilteredImage(Image<Bgr, byte> sourceImage, float allFactor, MaskType type)
{
Image<Bgr, byte> returnImage = new Image<Bgr, byte>(sourceImage.Width, sourceImage.Height);
float[,] firstTypeMatrix = new float[3, 3]
{
{0, -1, 0},
{ -1, allFactor + 4, -1},
{ 0, -1, 0}
};
float[,] secondTypeMatrix = new float[3, 3]
{
{-1, -1, -1},
{ -1, allFactor + 8, -1},
{-1, -1, -1}
};
ConvolutionKernelF matrix = null;
switch (type)
{
case MaskType.Type1:
matrix = new ConvolutionKernelF(firstTypeMatrix);
break;
case MaskType.Type2:
matrix = new ConvolutionKernelF(secondTypeMatrix);
break;
}
CvInvoke.Filter2D(sourceImage, returnImage, matrix, new Point(0, 0));
return returnImage;
}
// double[,] gR_Magnitude_Mat;
private void button3_Click(object sender, EventArgs e)
{
int scanFilterNum=0;
int W = Train_I.Width;
int H = Train_I.Height;
// Real part
Image<Gray, Double> gR_R = new Image<Gray, Double>(W, H);
gR_R2 = new double[m, n, 1];
gF_R_One_back = new float[m * n];
gF_R_back = new float[m, n];
gR_R3 = new double[H, W];
gR_R3_One = new double[H * W];
// Ouput
gR_R_Mat = new double[H * W, u * v];
// Ouput
gR_R_Picked = new Matrix<double>(H, W);
gR_R_Picked_Map = new Matrix<double>(H, W);
gR_R_One_Picked = new double[H * W];
gR_R_Picked_CS = new double[H, W];
// Imag part
Image<Gray, Double> gR_I = new Image<Gray, Double>(W, H);
double[, ,] gR_I2 = new double[m, n, 1];
float[] gF_I_One_back = new float[m * n];
float[,] gF_I_back = new float[m, n];
double[,] gR_I3 = new double[H, W];
double[] gR_I3_One = new double[H*W];
// Ouput
double[,] gR_I_Mat = new double[H*W, u*v];
// Ouput
Matrix<double> gR_I_Picked = new Matrix<double>(H, W);
Matrix<double> gR_I_Picked_Map = new Matrix<double>(H, W);
double[] gR_I_One_Picked = new double[H * W];
double[,] gR_I_Picked_CS = new double[H, W];
Matrix<double> t = new Matrix<double>(H, W);
/////////////// Filtered and save as gR_R_Mat / gR_I_Mat //////////////
for (scanFilterNum = 0; scanFilterNum < u * v; scanFilterNum++)
{
System.Console.WriteLine(scanFilterNum);
// Real part
gF_R_One_back = PickUpFilterFloat(gF_R_Mat.Data, scanFilterNum);
gF_R_back = OneToTwoFloat(gF_R_One_back, m, n); // OK
ConvolutionKernelF matrix_R = new ConvolutionKernelF(gF_R_back);
CvInvoke.cvFilter2D(Train_I, gR_R, matrix_R, new Point(0, 0));
gR_R2 = gR_R.Data;
gR_R3 = ArrayDownDim(gR_R2);
gR_R3_One = TwoToOneDouble(gR_R3);
// Imag part
gF_I_One_back = PickUpFilterFloat(gF_I_Mat.Data, pickFilterNum);
gF_I_back = OneToTwoFloat(gF_I_One_back, m, n);
ConvolutionKernelF matrix_I = new ConvolutionKernelF(gF_I_back);
CvInvoke.cvFilter2D(Train_I, gR_I, matrix_I, new Point(0, 0));
gR_I2 = gR_I.Data;
gR_I3 = ArrayDownDim(gR_I2);
gR_I3_One = TwoToOneDouble(gR_I3);
// Put into Mat
for (int q = 0; q < H * W; q++)
{
gR_R_Mat[q, scanFilterNum] = gR_R3_One[q];
gR_I_Mat[q, scanFilterNum] = gR_I3_One[q];
// gR_Magnitude_Mat[q, scanFilterNum] = Math.Sqrt((Math.Pow(gR_R3_One[q], 2) + Math.Pow(gR_I3_One[q], 2)));
}
}
/////////////// END Filtered and save as gR_R_Mat / gR_I_Mat //////////////
//////////////////////////////////////////////////////////////////// Test START/////////////////////////////////////////////////////////////////
double Imin; double Imax; Point IminLoc; Point ImaxLoc;
t.Data = gR_R3;
t.MinMax(out Imin, out Imax, out IminLoc, out ImaxLoc);
double kkk = ((Imax - Imin) / 255);
int W_gR_R3 = t.Width;
int H_gR_R3 = t.Height;
for (int i = 0; i < H_gR_R3; i++)
{
for (int j = 0; j < W_gR_R3; j++)
{
t.Data[i, j] = (float)(((t.Data[i, j] - (float)Imax) / kkk) + 255); // Mapping
}
}
t.Save(@"D:\Code\gF_R_back.bmp");
pictureBox7.Image = Image.FromFile(@"D:\Code\gF_R_back.bmp");
//////////////////////////////////////////////////////////////////// Test END /////////////////////////////////////////////////////////////////
/////////////////////////////// Show Real Part ////////////////////////////////
pickResultNum = 0;
gR_R_One_Picked = PickUpResultDouble(gR_R_Mat, pickResultNum); // Choose the p-th Gabor filtered Result
gR_R_Picked_CS = OneToTwoDouble(gR_R_One_Picked,H,W);
gR_R_Picked.Data = gR_R_Picked_CS;
// Show the choose filtered Result, mapping pixel value to [0,255]
double R_Rmin; double R_Rmax; Point R_RminLoc; Point R_RmaxLoc;
gR_R_Picked.MinMax(out R_Rmin, out R_Rmax, out R_RminLoc, out R_RmaxLoc);
double k = ((R_Rmax - R_Rmin) / 255);
int H_gR_R_Picked = gR_R_Picked.Rows;
int W_gR_R_Picked = gR_R_Picked.Cols;
for (int i = 0; i < H_gR_R_Picked; i++)
{
for (int j = 0; j < W_gR_R_Picked; j++)
{
gR_R_Picked_Map.Data[i, j] = (( (gR_R_Picked.Data[i, j] - R_Rmin) / k) ); // Mapping
}
}
gR_R_Picked_Map.Save(@"D:\Code\gR_R_Picked_Map.bmp");
pictureBox3.Image = Image.FromFile(@"D:\Code\gR_R_Picked_Map.bmp");
/////////////////////////////// Show Imagl Part ////////////////////////////////
gR_I_One_Picked = PickUpResultDouble(gR_I_Mat, pickResultNum); // Choose the p-th Gabor filtered Result
gR_I_Picked_CS = OneToTwoDouble(gR_I_One_Picked, H, W);
gR_I_Picked.Data = gR_I_Picked_CS;
// Show the choose filtered Result, mapping pixel value to [0,255]
double I_Rmin; double I_Rmax; Point I_RminLoc; Point I_RmaxLoc;
gR_I_Picked.MinMax(out I_Rmin, out I_Rmax, out I_RminLoc, out I_RmaxLoc);
double kk = ((I_Rmax - I_Rmin) / 255);
int H_gR_I_Picked = gR_I_Picked.Rows;
int W_gR_I_Picked = gR_I_Picked.Cols;
for (int i = 0; i < H_gR_I_Picked; i++)
{
for (int j = 0; j < W_gR_I_Picked; j++)
{
gR_I_Picked_Map.Data[i, j] = (((gR_I_Picked.Data[i, j] - I_Rmin) / kk)); // Mapping
}
}
gR_I_Picked_Map.Save(@"D:\Code\gR_I_Picked_Map.bmp");
pictureBox6.Image = Image.FromFile(@"D:\Code\gR_I_Picked_Map.bmp");
label14.Text = "pickResultNum = " + pickResultNum;
System.Console.WriteLine(" END OF button3_Click: Gabor Result");
}
public FeatureRecognizer()
{
isTrained = false;
SVMParameters = new SVMParams();
SVMParameters.SVMType = Emgu.CV.ML.MlEnum.SVM_TYPE.C_SVC;
//SVMParameters.SVMType = Emgu.CV.ML.MlEnum.SVM_TYPE.NU_SVC;
//p.KernelType = Emgu.CV.ML.MlEnum.SVM_KERNEL_TYPE.POLY;
//SVMParameters.KernelType = Emgu.CV.ML.MlEnum.SVM_KERNEL_TYPE.LINEAR;
SVMParameters.KernelType = Emgu.CV.ML.MlEnum.SVM_KERNEL_TYPE.POLY;
//SVMParameters.KernelType = Emgu.CV.ML.MlEnum.SVM_KERNEL_TYPE.RBF;
SVMParameters.Gamma = 3;
SVMParameters.Degree = 3;
SVMParameters.C = 1;
SVMParameters.TermCrit = new MCvTermCriteria(100, 0.00001);
//SVMParameters.Nu
//SVMParameters.P
//SVMParameters.Coef0 =
paramsm = new MCvSVMParams();
paramsm.svm_type = Emgu.CV.ML.MlEnum.SVM_TYPE.C_SVC;
paramsm.kernel_type = Emgu.CV.ML.MlEnum.SVM_KERNEL_TYPE.LINEAR;
paramsm.gamma = 2;
paramsm.degree = 3;
paramsm.C = 3;
paramsm.term_crit = new MCvTermCriteria(100, 0.00001);
//debugImages = new List<DebugImage>();
debugImages = null;
//SVMModel = new SVM();
// foreach(SignShape shape in Enum.GetValues(typeof(SignShape)))
for (int i = 0;i < signShapeCount;i++)
{
SVM model = new SVM();
SVMModels.Add(model);
}
int R = 10;
int C = 10;
double v = 2;
for (int i = 0; i < 8; i++)
{
GWOutputImage = GWOutputImage.ConcateHorizontal(GaborWavelet(R, C, i, v));
Image<Gray, double> GW = GaborWavelet(R, C, i, v);
ConvolutionKernelF ckernel = new ConvolutionKernelF(10, 10);
for (int l = 0; l < 10; l++)
for (int k = 0; k < 10; k++)
ckernel[l, k] = (float)GW[l, k].Intensity / 10000;
ckernel.Center = new Point(5, 5);
cKernelList.Add(ckernel);
}
}
