private void Go_Click(object sender, RoutedEventArgs e)
{
try
{
System.Windows.Media.Imaging.BitmapImage imagesource = imageBox.Source as System.Windows.Media.Imaging.BitmapImage;
if (imageBox.Source == null)
{
System.Windows.MessageBox.Show("Add your image to the Image 1 box!");
return;
}
System.Drawing.Bitmap image = BmpImage2Bmp(imagesource);
System.Windows.Media.Imaging.BitmapImage final = new System.Windows.Media.Imaging.BitmapImage();
if (!AForge.Imaging.Image.IsGrayscale(image))
{
AForge.Imaging.Filters.ExtractChannel Grayer = new AForge.Imaging.Filters.ExtractChannel(0);
image = Grayer.Apply(image);
}
if (Threshold.IsChecked == true)
{
imageBox.Source = null;
AForge.Imaging.Filters.Threshold threshold = new AForge.Imaging.Filters.Threshold((int)slider.Value);
threshold.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
else if (GaussianFilter.IsChecked == true)
{
AForge.Imaging.Filters.GaussianBlur Gauss = new AForge.Imaging.Filters.GaussianBlur();
Gauss.Sigma = GaussSigma_Slide.Value;
Gauss.Size = (int)GaussSize_Slide.Value;
AForge.Imaging.UnmanagedImage unmanagedImage = AForge.Imaging.UnmanagedImage.FromManagedImage(image);
AForge.Imaging.UnmanagedImage Dst = unmanagedImage.Clone();
Gauss.Apply(unmanagedImage, Dst);
final = Bmp2BmpImage(Dst.ToManagedImage());
}
else if (HiPass.IsChecked == true)
{
AForge.Imaging.Filters.Sharpen filter = new AForge.Imaging.Filters.Sharpen();
filter.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
else if (Erode.IsChecked == true)
{
AForge.Imaging.Filters.Erosion filter = new AForge.Imaging.Filters.Erosion();
filter.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
else if (Invert.IsChecked == true)
{
AForge.Imaging.Filters.Invert filter = new AForge.Imaging.Filters.Invert();
filter.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
else if (EdgeDetector.IsChecked == true)
{
AForge.Imaging.Filters.CannyEdgeDetector filter = new AForge.Imaging.Filters.CannyEdgeDetector();
filter.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
else if (Median.IsChecked == true)
{
AForge.Imaging.Filters.Median filter = new AForge.Imaging.Filters.Median();
filter.Size = (int)GaussSize_Slide.Value;
filter.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
else if (More.IsChecked == true)
{
if (Dilate.IsSelected)
{
AForge.Imaging.Filters.Dilatation filter = new AForge.Imaging.Filters.Dilatation();
filter.ApplyInPlace(image);
final = Bmp2BmpImage(image);
}
}
imageBox.Source = final;
TransformImage = image;
boxWidth = imageBox.RenderSize.Width;
boxHeight = imageBox.RenderSize.Height;
}
catch (Exception exc)
{
System.Windows.MessageBox.Show(exc.ToString());
}
}
unsafe static void Main()
{
Test test = new Test();
test.TestRunningWeightedVariance();
return;
var resourceDir = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "Resources");
var imgColor = Bitmap.FromFile(Path.Combine(resourceDir, "testColorBig.jpg")).ToImage <Bgr, byte>();
imgColor = imgColor.CorrectContrast(105);
/*var bmp1 = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile("nature-spring.jpg");
* var image1 = bmp1.ToImage<Gray, float>();
*
* var res1 = ResizeNearsetNeighbur.Resize(image1, new Size(640, 480));
* ImageBox.Show("Interpolated image", res1.ToBitmap());
*
* var res = new Image<Bgr, float>(320, 200);
* image1.GetRectSubPix(new PointF(1.9f, 1.9f), res);
* ImageBox.Show("Interpolated image", res.ToBitmap());*/
test.TestLKFlow();
return; //uncomment if you want execute functions below
var bmp = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile("nature-spring.jpg");
var image = bmp.ToImage <Bgr, byte>();
UnmanagedImage uIm = UnmanagedImage.FromManagedImage(bmp);
/********************** Bitmap <-> Image<,> *************************/
//from Bitmap...
IImage bmpImg1 = bmp.ToImage(); //generic image (dest format depends on bmp pixel format) (this case: <Color3, byte>)
Image <Bgr, byte> bmpImg2 = bmp.ToImage <Bgr, byte>(); //in this case additional cast is performed (<Color3, byte> => <Bgr, byte>) (no data convert)
//to Bitmap...
Bitmap bmpFromImg = bmpImg2.ToBitmap(copyAlways: false /*do not copy if you do not have to*/); //<Bgr, byte> can be casted to <Color3, byte> therefore data is shared between Bitmap and bmPimg2
/********************** UnmanagedImage <-> Image<,> *************************/
//from UnmanagedImage...
var im1FromUIm = uIm.AsImage(); //generic image (dest format depends on bmp pixel format)
var im2FromUIm = uIm.ToImage <Bgr, byte>(); //in this case additional cast is performed (<Color3, byte> => <Bgr, byte>) (no data convert)
//to UnmanagedImage...
var uIm2 = im1FromUIm.ToAForgeImage(copyAlways: false, failIfCannotCast: false);
/******************* some AForge filter recreation... ***********************/
/********************** Array <-> Image<,> (also eliminates need for Matrix, UnmanagedImage converters) ********************************/
int[,] arr = new int[480, 640];
//from Array...
var image1FromArray = arr.ToImage(); //supported for all 2D/3D arrays
var castedImageFromArray = arr.AsImage(); //supported only on 2D arrays (data is shared)
//to Array ...
var arrFromIm = image1FromArray.ToArray(); //output is 2D or 3D array (see function overloads)
/**************** channel rotate *******************/
//Image<,> => flexible
var channels = image.SplitChannels();
var dest = new Image <Bgr, byte>(new Image <Gray, byte>[] { channels[1], channels[0], channels[2] });
//AForge
AForge.Imaging.Filters.RotateChannels rc = new AForge.Imaging.Filters.RotateChannels();
rc.Apply(uIm);
/**************** channel extract *******************/
//Image<,> => simple
var ch = image[0];
//AForge
AForge.Imaging.Filters.ExtractChannel ec = new AForge.Imaging.Filters.ExtractChannel(0);
ec.Apply(uIm);
/**************** Max (see Min also) *******************/
//Image<,>
image.Max(image, inPlace: true);
//AForge
AForge.Imaging.Filters.Merge m = new AForge.Imaging.Filters.Merge(uIm);
m.Apply(uIm);
/**************** Sobel *******************/
var bmpSquareGray = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile("square.bmp");
var grayIm = bmpSquareGray.ToImage <Gray, float>(); //currently there are no overloads for magnitude for <byte>, will be fixed later
//Image<,> => flexible
var sobelX = grayIm.Sobel(1, 0, 3);
var sobelY = grayIm.Sobel(0, 1, 3);
var mag = sobelX.Magnitude(sobelY); //should use Threshold for values > 255 (not implemented yet)
//mag.ToBitmap().Save("bla.bmp"); //img.Save(..) is available for <IColor3, byte> and <Gray, byte> (Bitmap compatible formats) should change ?
//var mag = sobelX.Abs().Add(sobelY.Abs()).Scale(0, 255).Convert<Gray, byte>(); //should work later (it is not implemented)
//AForge
AForge.Imaging.Filters.SobelEdgeDetector sobel = new AForge.Imaging.Filters.SobelEdgeDetector();
var destSobel = sobel.Apply(grayIm.ToAForgeImage());
//destSobel.ToManagedImage().Save("sobelAForge.bmp");
return;
}
private void nowyObraz(object sender, NewFrameEventArgs eventArgs)
{
Bitmap bitmap = new Bitmap((Bitmap)eventArgs.Frame.Clone());
AForge.Imaging.Filters.ExtractChannel filterC;
int x, y;
Color c;
//pictureBox1.Image = bitmap;
switch (this.tryb)
{
case 0:
pictureBox1.Image = bitmap;
break;
case 1:
var filter = AForge.Imaging.Filters.Grayscale.CommonAlgorithms.RMY;
bitmap = filter.Apply(bitmap);
pictureBox1.Image = bitmap;
break;
case 2:
filterC = new AForge.Imaging.Filters.ExtractChannel(RGB.R);
bitmap = filterC.Apply(bitmap);
pictureBox1.Image = bitmap;
break;
case 3:
filterC = new AForge.Imaging.Filters.ExtractChannel(RGB.G);
bitmap = filterC.Apply(bitmap);
pictureBox1.Image = bitmap;
break;
case 4:
filterC = new AForge.Imaging.Filters.ExtractChannel(RGB.B);
bitmap = filterC.Apply(bitmap);
pictureBox1.Image = bitmap;
break;
case 5:
Bitmap temp = new Bitmap(bitmap);
int j, k, l;
for (x = 1; x < temp.Width - 1; x++) //nie operujemy na krawedziach
{
for (y = 1; y < temp.Height - 1; y++)
{
j = k = l = 1020;
c = bitmap.GetPixel(x - 1, y);
j -= c.R;
k -= c.G;
l -= c.B;
c = bitmap.GetPixel(x, y - 1);
j -= c.R;
k -= c.G;
l -= c.B;
c = bitmap.GetPixel(x, y + 1);
j -= c.R;
k -= c.G;
l -= c.B;
c = bitmap.GetPixel(x + 1, y);
j -= c.R;
k -= c.G;
l -= c.B;
c = bitmap.GetPixel(x, y);
j += 4 * c.R;
k += 4 * c.G;
l += 4 * c.B;
j /= 8;
k /= 8;
l /= 8;
c = Color.FromArgb(j, k, l);
temp.SetPixel(x, y, c);
}
}
pictureBox1.Image = temp;
break;
case 6:
for (x = 0; x < bitmap.Width; x++)
{
for (y = 0; y < bitmap.Height; y++)
{
c = bitmap.GetPixel(x, y);
if (c.R + c.G + c.B > 254)
{
bitmap.SetPixel(x, y, Color.FromArgb(255, 255, 255)); //wspolczynniki wybrane ze wzgledu na ciemnosc pokoju
}
else
{
bitmap.SetPixel(x, y, Color.FromArgb(0, 0, 0));
}
}
}
pictureBox1.Image = bitmap;
break;
}
}
static unsafe void Main()
{
Test test = new Test();
var resourceDir = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "Resources");
var imgColor = Bitmap.FromFile(Path.Combine(resourceDir, "testColorBig.jpg")).ToImage<Bgr, byte>();
imgColor = imgColor.CorrectContrast(105);
/*var bmp1 = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile("nature-spring.jpg");
var image1 = bmp1.ToImage<Gray, float>();
var res1 = ResizeNearsetNeighbur.Resize(image1, new Size(640, 480));
ImageBox.Show("Interpolated image", res1.ToBitmap());
var res = new Image<Bgr, float>(320, 200);
image1.GetRectSubPix(new PointF(1.9f, 1.9f), res);
ImageBox.Show("Interpolated image", res.ToBitmap());*/
test.TestLKFlow();
return; //uncomment if you want execute functions below
var bmp = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile("nature-spring.jpg");
var image = bmp.ToImage<Bgr, byte>();
UnmanagedImage uIm = UnmanagedImage.FromManagedImage(bmp);
/********************** Bitmap <-> Image<,> *************************/
//from Bitmap...
IImage bmpImg1 = bmp.ToImage(); //generic image (dest format depends on bmp pixel format) (this case: <Color3, byte>)
Image<Bgr, byte> bmpImg2 = bmp.ToImage<Bgr, byte>(); //in this case additional cast is performed (<Color3, byte> => <Bgr, byte>) (no data convert)
//to Bitmap...
Bitmap bmpFromImg = bmpImg2.ToBitmap(copyAlways: false /*do not copy if you do not have to*/); //<Bgr, byte> can be casted to <Color3, byte> therefore data is shared between Bitmap and bmPimg2
/********************** UnmanagedImage <-> Image<,> *************************/
//from UnmanagedImage...
var im1FromUIm = uIm.AsImage(); //generic image (dest format depends on bmp pixel format)
var im2FromUIm = uIm.ToImage<Bgr, byte>(); //in this case additional cast is performed (<Color3, byte> => <Bgr, byte>) (no data convert)
//to UnmanagedImage...
var uIm2 = im1FromUIm.ToAForgeImage(copyAlways: false, failIfCannotCast: false);
/******************* some AForge filter recreation... ***********************/
/********************** Array <-> Image<,> (also eliminates need for Matrix, UnmanagedImage converters) ********************************/
int[,] arr = new int[480,640];
//from Array...
var image1FromArray = arr.ToImage(); //supported for all 2D/3D arrays
var castedImageFromArray = arr.AsImage(); //supported only on 2D arrays (data is shared)
//to Array ...
var arrFromIm = image1FromArray.ToArray(); //output is 2D or 3D array (see function overloads)
/**************** channel rotate *******************/
//Image<,> => flexible
var channels = image.SplitChannels();
var dest = new Image<Bgr, byte>(new Image<Gray, byte>[] { channels[1], channels[0], channels[2] });
//AForge
AForge.Imaging.Filters.RotateChannels rc = new AForge.Imaging.Filters.RotateChannels();
rc.Apply(uIm);
/**************** channel extract *******************/
//Image<,> => simple
var ch = image[0];
//AForge
AForge.Imaging.Filters.ExtractChannel ec = new AForge.Imaging.Filters.ExtractChannel(0);
ec.Apply(uIm);
/**************** Max (see Min also) *******************/
//Image<,>
image.Max(image, inPlace:true);
//AForge
AForge.Imaging.Filters.Merge m = new AForge.Imaging.Filters.Merge(uIm);
m.Apply(uIm);
/**************** Sobel *******************/
var bmpSquareGray = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile("square.bmp");
var grayIm = bmpSquareGray.ToImage<Gray, float>(); //currently there are no overloads for magnitude for <byte>, will be fixed later
//Image<,> => flexible
var sobelX = grayIm.Sobel(1, 0, 3);
var sobelY = grayIm.Sobel(0, 1, 3);
var mag = sobelX.Magnitude(sobelY); //should use Threshold for values > 255 (not implemented yet)
//mag.ToBitmap().Save("bla.bmp"); //img.Save(..) is available for <IColor3, byte> and <Gray, byte> (Bitmap compatible formats) should change ?
//var mag = sobelX.Abs().Add(sobelY.Abs()).Scale(0, 255).Convert<Gray, byte>(); //should work later (it is not implemented)
//AForge
AForge.Imaging.Filters.SobelEdgeDetector sobel = new AForge.Imaging.Filters.SobelEdgeDetector();
var destSobel = sobel.Apply(grayIm.ToAForgeImage());
//destSobel.ToManagedImage().Save("sobelAForge.bmp");
return;
}
