private void EdgeDetectImg(ref Bitmap frame)
{
frame = Grayscale.CommonAlgorithms.RMY.Apply(frame); // Make gray
switch (EdgeDetectValue)
{
case 1:
SobelEdgeDetector SobelFilter = new SobelEdgeDetector();
SobelFilter.ApplyInPlace(frame);
break;
case 2:
DifferenceEdgeDetector DifferenceFilter = new DifferenceEdgeDetector();
DifferenceFilter.ApplyInPlace(frame);
break;
case 3:
HomogenityEdgeDetector HomogenityFilter = new HomogenityEdgeDetector();
HomogenityFilter.ApplyInPlace(frame);
break;
case 4:
CannyEdgeDetector Cannyfilter = new CannyEdgeDetector();
// apply the MirrFilter
Cannyfilter.ApplyInPlace(frame);
break;
default:
HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
filter.ApplyInPlace(frame);
break;
}
GrayscaleToRGB RGBfilter = new GrayscaleToRGB(); // back to color format
frame = RGBfilter.Apply(frame);
}
public mEdgeHomogenity()
{
BitmapType = mFilter.BitmapTypes.GrayscaleBT709;
Effect = new HomogenityEdgeDetector();
filter = Effect;
}
private void reapplyToolStripMenuItem4_Click(object sender, EventArgs e)
{
//GrayscaleBT709 grayObject = new GrayscaleBT709();
//pictureBox2.Image = grayObject.Apply((Bitmap)pictureBox2.Image);
HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
pictureBox2.Image = filter.Apply((Bitmap)pictureBox2.Image);
}
void preprocess()
{
Bitmap preprocessedImage = originalImage;
//Grayscale
preprocessedImage = Grayscale.CommonAlgorithms.BT709
.Apply(preprocessedImage);
//Edge Detection / Threshold
preprocessedImage = new HomogenityEdgeDetector()
.Apply(preprocessedImage);
//Crop / Reduce Noise
int xMin, xMax, yMin, yMax;
xMin = preprocessedImage.Width;
yMin = preprocessedImage.Height;
xMax = 0; yMax = 0;
for (int i = 0; i < preprocessedImage.Width; i++)
{
for (int j = 0; j < preprocessedImage.Height; j++)
{
if (preprocessedImage.GetPixel(i, j).R > 100)
{
if (i < xMin)
{
xMin = i;
}
if (j < yMin)
{
yMin = j;
}
if (i > xMax)
{
xMax = i;
}
if (j > yMax)
{
yMax = j;
}
}
}
}
Bitmap cropped;
cropped = new Bitmap(xMax, yMax);
Graphics.FromImage(cropped)
.DrawImage(preprocessedImage, xMin, yMin, xMax, yMax);
//Resize
cropped = new ResizeBilinear(maxWidth, maxHeight).Apply(cropped);
pictureBox1.Image = cropped;
}
public Bitmap preprocessing(Bitmap image)
{
image = image.Clone(new Rectangle(0, 0, image.Width, image.Height), System.Drawing.Imaging.PixelFormat.Format24bppRgb);
image = Grayscale.CommonAlgorithms.BT709.Apply(image);
image = new Threshold(127).Apply(image);
image = new HomogenityEdgeDetector().Apply(image);
int x = image.Width, y = image.Height, width = 0, height = 0;
for (int i = 0; i < image.Height; i++)
{
for (int j = 0; j < image.Width; j++)
{
if (image.GetPixel(j, i).R > 127)
{
if (x > j)
{
x = j;
}
if (y > i)
{
y = i;
}
if (width < j)
{
width = j;
}
if (height < i)
{
height = i;
}
}
}
}
image = image.Clone(new Rectangle(x, y, width - x, height - y), System.Drawing.Imaging.PixelFormat.Format24bppRgb);
image = new ResizeBilinear(100, 100).Apply(image);
return(image);
}
public void HomogenityClickHandler(object sender, EventArgs e)
{
if (image != null)
{
Bitmap imx = new Bitmap(path);
imx = Grayscale.CommonAlgorithms.Y.Apply(imx);
HomogenityEdgeDetector gb = new HomogenityEdgeDetector();
imx = gb.Apply(imx);
if (mov != null)
{
this.WorkItem.Workspaces[WorkspaceNames.TabWorkspace].Close(mov);
}
mov = this.WorkItem.SmartParts.AddNew <ImageAView>();
mov.panAndZoomPictureBox1.Image = imx;
SmartPartInfo spi =
new SmartPartInfo("Homogenity", "MyOwnDescription");
this.WorkItem.Workspaces[WorkspaceNames.TabWorkspace].Show(mov, spi);
}
}
public void GenerateThumbnails(ThumbnailGenerationParameters parameters)
{
var textureConverterFactory = new TextureConverterFactory();
using (var textureConverter = textureConverterFactory.Create()) {
IFilter grayscaleFilter = new Grayscale(0.3, 0.59, 0.11);
IInPlaceFilter edgeDetectionFilter = new HomogenityEdgeDetector();
SliceRatingCalculator ratingCalculator = new SliceRatingCalculator();
var utilities = new ThumbnailGeneratorUtilities(textureConverter);
var slicePicker = new SlicePicker(grayscaleFilter, edgeDetectionFilter, ratingCalculator, utilities);
var aspectRatio = 16 / (double)9;
var sliceCount = 5;
var resultWidth = 400;
var resultHeight = (int)(resultWidth / aspectRatio);
var sliceWidth = resultWidth / sliceCount;
var bitmaps = utilities.EnumerateBitmapsRandomly(parameters.SourceDirectory).Take(100).ToList();
var slices = slicePicker.PickSlices(bitmaps, new Size(sliceWidth, resultHeight));
var sliceCombiner = new SliceCombiner(utilities, grayscaleFilter);
for (var i = 0; i < parameters.ThumbnailsToGenerate; i++)
{
var bitmap = sliceCombiner.CombineSlices(slices, kSlicesPerThumbnail);
using (var ms = new MemoryStream()) {
bitmap.Save(ms, ImageFormat.Jpeg);
ms.Position = 0;
var hash = MD5.Create().ComputeHash(ms).ToHex();
var outputName = hash + "_" + DateTime.UtcNow.GetUnixTime().ToString() + ".jpg";
var outputPath = Path.Combine(parameters.DestinationDirectory, outputName);
ms.Position = 0;
using (var fs = File.OpenWrite(outputPath)) {
ms.CopyTo(fs);
}
}
}
}
}
// =========================================================
private void Edge_detectFunc(ref Bitmap frame, int par_int)
{
frame = Grayscale.CommonAlgorithms.RMY.Apply(frame); // Make gray
switch (par_int)
{
case 1:
SobelEdgeDetector SobelFilter = new SobelEdgeDetector();
SobelFilter.ApplyInPlace(frame);
break;
case 2:
DifferenceEdgeDetector DifferenceFilter = new DifferenceEdgeDetector();
DifferenceFilter.ApplyInPlace(frame);
break;
case 3:
HomogenityEdgeDetector HomogenityFilter = new HomogenityEdgeDetector();
HomogenityFilter.ApplyInPlace(frame);
break;
case 4:
// can we not have references to canny in the code. gives me ptsd flashbacks
CannyEdgeDetector Nightmare = new CannyEdgeDetector();
// apply the filter
Nightmare.ApplyInPlace(frame);
break;
default:
HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
filter.ApplyInPlace(frame);
break;
}
GrayscaleToRGB RGBfilter = new GrayscaleToRGB(); // back to color format
frame = RGBfilter.Apply(frame);
}
public HomogenityEdgeDetectorFilter()
{
homogenityEdgeDetector = new HomogenityEdgeDetector();
}
public static Bitmap FilterImage(Bitmap img, int filter)
{
Bitmap sourceImage = img;
sourceImage = ImageUtil.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
IFilter myFilter;
Bitmap filteredImage = sourceImage;
if (filter == Filters.filters["Greyscale"])
{
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
filteredImage = sourceImage;
}
else if (filter == Filters.filters["Sepia"])
{
myFilter = new Sepia();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Invert"])
{
sourceImage = ImageUtil.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
myFilter = new Invert();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["RotateChannel"])
{
myFilter = new RotateChannels();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Threshold"])
{
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new Threshold();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["FloydFilter"])
{
FloydSteinbergColorDithering myReduction = new FloydSteinbergColorDithering();
filteredImage = myReduction.Apply(sourceImage);
}
else if (filter == Filters.filters["OrderedDithering"])
{
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new OrderedDithering();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Sharpen"])
{
myFilter = new Sharpen();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["DifferenceEdgeDetector"])
{
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new DifferenceEdgeDetector();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["HomogenityEdgeDetector"])
{
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new HomogenityEdgeDetector();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Sobel"])
{
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new SobelEdgeDetector();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Jitter"])
{
myFilter = new Jitter(); //Needs Expand
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["OilPainting"])
{
sourceImage = ImageUtil.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
myFilter = new OilPainting(); //Needs Expand
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["TextureFiltering"])
{
sourceImage = ImageUtil.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
myFilter = new Texturer(new TextileTexture(), 1.0, 0.8); //Needs Expand
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Median"])
{
sourceImage = ImageUtil.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
myFilter = new Median();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Mean"])
{
myFilter = new Mean();
filteredImage = myFilter.Apply(sourceImage);
}
else if (filter == Filters.filters["Blur"])
{
myFilter = new GaussianBlur();
filteredImage = myFilter.Apply(sourceImage);
}
//Console.Write(filteredImage.PixelFormat.ToString());
//Console.Write(sourceImage.PixelFormat.ToString());
filteredImage = ImageUtil.convert(filteredImage, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
return(filteredImage);
}
private void homonietyEdgeToolStripMenuItem_Click(object sender, EventArgs e)
{
islem = new GrayscaleBT709().Apply(kaynak);
islem = new HomogenityEdgeDetector().Apply(islem);
islemBox.Image = islem;
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object can be used to retrieve data from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
Bitmap sourceImage = null;
DA.GetData(0, ref sourceImage);
string filter = "";
DA.GetData(1, ref filter);
sourceImage = ImageUtilities.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
IFilter myFilter;
Bitmap filteredImage = sourceImage;
//Grayscale.CommonAlgorithms.Y.Apply
switch (filter)
{
case "Greyscale":
Console.Write("Applying: " + filter);
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
filteredImage = sourceImage;
break;
case "Sepia":
Console.Write("Applying: " + filter);
myFilter = new Sepia();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Invert":
Console.Write("Applying: " + filter);
sourceImage = ImageUtilities.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
myFilter = new Invert();
filteredImage = myFilter.Apply(sourceImage);
break;
case "RotateChannel":
Console.Write("Applying: " + filter);
myFilter = new RotateChannels();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Threshold": //Need Extended Version
Console.Write("Applying: " + filter);
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new Threshold();
filteredImage = myFilter.Apply(sourceImage);
break;
case "FloydFilter":
Console.Write("Applying: " + filter);
//sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
//myFilter = new FloydSteinbergColorDithering();
FloydSteinbergColorDithering myReduction = new FloydSteinbergColorDithering();
filteredImage = myReduction.Apply(sourceImage);
//filteredImage = myFilter.Apply(sourceImage);
break;
case "OrderedDithering":
Console.Write("Applying: " + filter);
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new OrderedDithering();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Sharpen":
Console.Write("Applying: " + filter);
myFilter = new Sharpen();
filteredImage = myFilter.Apply(sourceImage);
break;
case "DifferenceEdgeDetector":
Console.Write("Applying: " + filter);
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new DifferenceEdgeDetector();
filteredImage = myFilter.Apply(sourceImage);
break;
case "HomogenityEdgeDetector":
Console.Write("Applying: " + filter);
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new HomogenityEdgeDetector();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Sobel":
Console.Write("Applying: " + filter);
sourceImage = Grayscale.CommonAlgorithms.RMY.Apply(sourceImage);
myFilter = new SobelEdgeDetector();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Jitter":
Console.Write("Applying: " + filter);
myFilter = new Jitter(); //Needs Expand
filteredImage = myFilter.Apply(sourceImage);
break;
case "OilPainting":
Console.Write("Applying: " + filter);
myFilter = new OilPainting(); //Needs Expand
filteredImage = myFilter.Apply(sourceImage);
break;
case "TextureFiltering":
Console.Write("Applying: " + filter);
sourceImage = ImageUtilities.convert(sourceImage, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
myFilter = new Texturer(new TextileTexture(), 1.0, 0.8); //Needs Expand
filteredImage = myFilter.Apply(sourceImage);
break;
case "Median":
Console.Write("Applying: " + filter);
myFilter = new Median();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Mean":
Console.Write("Applying: " + filter);
myFilter = new Mean();
filteredImage = myFilter.Apply(sourceImage);
break;
case "Blur": //Need Extended Version
Console.Write("Applying: " + filter);
myFilter = new GaussianBlur();
filteredImage = myFilter.Apply(sourceImage);
break;
default:
Console.Write("No Filter");
break;
}
Console.Write(filteredImage.PixelFormat.ToString());
Console.Write(sourceImage.PixelFormat.ToString());
filteredImage = ImageUtilities.convert(filteredImage, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
DA.SetData(0, filteredImage);
}
public override Bitmap ApplyFilter(List <Bitmap> bitmaps)
{
HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
return(filter.Apply(bitmaps[0].ConvertPixelFormat(PixelFormat.Format16bppGrayScale)));
}
private void video_NewFrame1(object sender, NewFrameEventArgs eventArgs)
{
videoCapture.Stop();
pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
pictureBox2.SizeMode = PictureBoxSizeMode.CenterImage;
pictureBox1.Image = (Bitmap)eventArgs.Frame.Clone();
//pictureBox2.Image = (Bitmap)eventArgs.Frame.Clone();
image = (Bitmap)eventArgs.Frame.Clone();
byte[,] matrix = new byte[4, 4]
{
{ 95, 233, 127, 255 },
{ 159, 31, 191, 63 },
{ 111, 239, 79, 207 },
{ 175, 47, 143, 15 }
};
switch (choice)
{
case 0:
{
}
break;
//Threshold
case 1:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
Threshold filter = new Threshold(100);
applyfilter(filter);
}
break;
//OrderedDithering
case 2:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
OrderedDithering filter = new OrderedDithering(matrix);
applyfilter(filter);
}
break;
//BayerDithering
case 3:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
BayerDithering filter = new BayerDithering();
applyfilter(filter);
}
break;
//floyd
case 4:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
FloydSteinbergDithering filter = new FloydSteinbergDithering();
applyfilter(filter);
}
break;
//burkes
case 5:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
BurkesDithering filter = new BurkesDithering();
applyfilter(filter);
}
break;
//jarvis
case 6:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
JarvisJudiceNinkeDithering filter = new JarvisJudiceNinkeDithering();
applyfilter(filter);
}
break;
//sierra
case 7:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
SierraDithering filter = new SierraDithering();
applyfilter(filter);
}
break;
//stucki
case 8:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
StuckiDithering filter = new StuckiDithering();
applyfilter(filter);
}
break;
//Homogenity
case 9:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
applyfilter(filter);
}
break;
//rotate
case 10:
{
applyfilter(new RotateChannels());
} break;
//sobel
case 11:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
SobelEdgeDetector filter = new SobelEdgeDetector();
applyfilter(filter);
}
break;
//canny
case 12:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
CannyEdgeDetector filter = new CannyEdgeDetector();
applyfilter(filter);
}
break;
case 13:
{
applyfilter(new YCbCrFiltering());
} break;
case 14:
{
applyfilter(new HueModifier(180));
} break;
//SIS Threshold
case 15:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
SISThreshold filter = new SISThreshold();
applyfilter(filter);
} break;
//Difference
case 16:
{
Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
DifferenceEdgeDetector filter = new DifferenceEdgeDetector();
applyfilter(filter);
} break;
//mirror
case 17:
{
applyfilter(new Mirror(false, true));
} break;
//flip
case 18:
{
applyfilter(new RotateBilinear(180, true));
} break;
//Erosion
case 19:
{
applyfilter1(new Erosion());
} break;
//Dilatation
case 20:
{
applyfilter1(new Dilatation());
} break;
//Opening
case 21:
{
applyfilter1(new Opening());
} break;
//closing
case 22:
{
applyfilter1(new Closing());
} break;
//jitter
case 23:
{
applyfilter(new Jitter(15));
} break;
//OilPainting
case 24:
{
applyfilter(new OilPainting(10));
} break;
//pixellate
case 25:
{
applyfilter(new Pixellate(10));
} break;
}
}
private void openFileDialog1_FileOk(object sender, CancelEventArgs e)
{
loaded = new Bitmap(openFileDialog1.FileName);
pictureBox1.Image = loaded;
processed = new Bitmap(openFileDialog1.FileName);
GrayscaleBT709 g = new GrayscaleBT709();
processed = g.Apply((Bitmap)processed);
Threshold t = new Threshold(128);
processed = t.Apply((Bitmap)processed);
BlobsFiltering b = new BlobsFiltering();
b.MinWidth = 147;
b.MinHeight = 147;
b.CoupledSizeFiltering = true;
processed = b.Apply((Bitmap)processed);
HomogenityEdgeDetector h = new HomogenityEdgeDetector();
processed = h.Apply((Bitmap)processed);
pictureBox2.Image = processed;
BlobCounterBase bc = new BlobCounter();
bc.ProcessImage(processed);
Blob[] blobs = bc.GetObjectsInformation();
//5 cents 7 pieces 700-800 pixels
//10 cents 11 pieces 801-1000 pixels
//25 cents 28 pieces 1001-1200 pixels
//1 peso 13 pieces 1200-1500 pixels
//5 peso 5 pieces 1501-1700 pixels
int paybcents = 0, tencents = 0, twenypaybcents = 0, wanpeso = 0, paybpeso = 0;
foreach (Blob blob in blobs)
{
if (blob.Area >= 700 && blob.Area <= 800)
{
paybcents++;
}
else if (blob.Area >= 801 && blob.Area <= 1000)
{
tencents++;
}
else if (blob.Area >= 1001 && blob.Area <= 1200)
{
twenypaybcents++;
}
else if (blob.Area >= 1200 && blob.Area <= 1500)
{
wanpeso++;
}
else if (blob.Area >= 1501 && blob.Area <= 1700)
{
paybpeso++;
}
}
double paybcentsbalyo = paybcents * 0.05;
double tencentsbalyo = tencents * 0.1;
double twenypaybcentsbalyo = twenypaybcents * 0.25;
double wanpesobalyo = wanpeso * 1;
double paybpesobalyo = paybpeso * 5;
double total = paybcentsbalyo + tencentsbalyo + twenypaybcentsbalyo + wanpesobalyo + paybpesobalyo;
MessageBox.Show("5 cents: " + paybcents + " pieces value: " + paybcentsbalyo + "\n10 cents: " + tencents + " pieces value: " + tencentsbalyo + "\n25 cents: " + twenypaybcents + " pieces value:" + twenypaybcentsbalyo + "\n1 peso: " + wanpeso + " pieces value:" + wanpesobalyo + "\n5 peso: " + paybpeso + " pieces value:" + paybpesobalyo + "\nTotal Value: " + total);
}
Bitmap preprocessImage(Bitmap image)
{
int threshold = 127;
//Grayscale
Bitmap result = new Bitmap(image);
result = Grayscale.CommonAlgorithms.RMY.Apply(result);
//detect edge
result = new HomogenityEdgeDetector().Apply(result);
//Reduce Noise
int xMin, yMin, xMax, yMax;
xMin = image.Width; yMin = image.Height;
xMax = 0; yMax = 0;
for (int i = 0; i < image.Width; i++)
{
for (int j = 0; j < image.Height; j++)
{
if (image.GetPixel(i, j).R > threshold)
{
if (i < xMin)
{
xMin = i;
}
if (j < yMin)
{
yMin = j;
}
if (i > xMax)
{
xMax = i;
}
if (j > yMax)
{
yMax = j;
}
}
}
}
if (xMin == image.Width)
{
xMin = 0;
}
if (yMin == image.Height)
{
yMin = 0;
}
if (xMax == 0)
{
xMax = image.Width;
}
if (yMax == 0)
{
yMax = image.Height;
}
//crop
Bitmap cropped = new Bitmap(xMax, yMax);
Graphics.FromImage(cropped).DrawImage(image, xMin, yMin, xMax, yMax);
//resize
result = new ResizeBilinear(10, 10).Apply(result);
return(result);
}
private void FillPictureBoxes(ref Bitmap image)
{
Bitmap tmpImg = image;
Bitmap tmpImg2 = image;
try
{
bool hasFilter = false;
//setup resize and filtersequesce
//resize img to fit picturebox
ResizeBicubic resizeFilter = new ResizeBicubic(0, 0);
resizeFilter = new ResizeBicubic(pbCapture.Width, pbCapture.Height);
tmpImg = resizeFilter.Apply(tmpImg);
resizeFilter = new ResizeBicubic(pbShapes.Width, pbShapes.Height);
tmpImg2 = resizeFilter.Apply(tmpImg2);
FiltersSequence processingFilter = new FiltersSequence();
//List all filters
IFilter ConservativeSmoothingFilter = new AForge.Imaging.Filters.ConservativeSmoothing();
IFilter InvertFilter = new AForge.Imaging.Filters.Invert();
IFilter HSLFilteringFilter = new AForge.Imaging.Filters.HSLFiltering();
IFilter SepiaFilter = new AForge.Imaging.Filters.Sepia();
IFilter grayscaleFilter = new AForge.Imaging.Filters.GrayscaleBT709();
IFilter SkeletonizationFilter = new AForge.Imaging.Filters.SimpleSkeletonization();
IFilter pixFilter = new AForge.Imaging.Filters.Pixellate();
////apply filter and process img---------------------------------------------
if (ConservativeSmoothing)
{
processingFilter.Add(ConservativeSmoothingFilter);
hasFilter = true;
}
if (Invert)
{
processingFilter.Add(InvertFilter);
hasFilter = true;
}
if (HSLswitch)
{
processingFilter.Add(HSLFilteringFilter);
hasFilter = true;
}
if (sepiaSwitch)
{
processingFilter.Add(SepiaFilter);
hasFilter = true;
}
if (Skeletonization)
{
processingFilter.Add(grayscaleFilter);
processingFilter.Add(SkeletonizationFilter);
hasFilter = true;
}
//apply the filter(s) to image
if (hasFilter)
{
//tmpImg = processingFilter.Apply(tmpImg);
tmpImg2 = processingFilter.Apply(tmpImg2);
}
processingFilter.Clear();
if (bwSwitch)
{
switchBandW(ref tmpImg);
}
if (CannyEdgeDetector)
{
// create filter
CannyEdgeDetector filter = new CannyEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
filter.ApplyInPlace(tmpImg);
// image = DrawFocusArea(gsImage);
}
else
{
// image = DrawFocusArea(image);
}
if (DifferenceEdgeDetector)
{
DifferenceEdgeDetector dFilter = new DifferenceEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
dFilter.ApplyInPlace(tmpImg);
}
if (HomogenityEdgeDetector)
{
HomogenityEdgeDetector hFilter = new HomogenityEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
hFilter.ApplyInPlace(tmpImg);
}
if (SobelEdgeDetector)
{
SobelEdgeDetector hFilter = new SobelEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
hFilter.ApplyInPlace(tmpImg);
BlobCounter bc = new BlobCounter(tmpImg);
Rectangle[] brecs = bc.GetObjectsRectangles();
//Graphics pg = Graphics.FromImage(tmpImg);
//Pen p = new Pen(Color.White, 2);
//foreach (Rectangle r in brecs)
//{
// pg.DrawRectangle(p, r);
//}
}
if (findShapes)
{
tmpImg = FindShapes(tmpImg, ref tmpImg2);
//ProcessImage(image);
}
else
{
pbCapture.Image = tmpImg; //set picturebox image----------------
pbShapes.Image = tmpImg2; //set picturebox image----------------
}
// Graphics g = Graphics.FromImage(tmpImg);
// Pen p = new Pen(Color.Red, 2);
// Rectangle lr = new Rectangle(100, 120, 80, 40);
//// Rectangle rr = new Rectangle(360, 220, 80, 40);
// g.DrawRectangle(p, lr);
// //g.DrawRectangle(p, rr);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
// pbCapture.Image = tmpImg;//set picturebox image----------------
// pbShapes.Image = tmpImg2;//set picturebox image----------------
}
public Bitmap Detect(Bitmap bitmap)
{
Bitmap grayscaleBitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
IFilter smoothingFilter = null;
switch (_smoothMode)
{
case "None": smoothingFilter = null; break;
case "Mean": smoothingFilter = new Mean(); break;
case "Median": smoothingFilter = new Median(); break;
case "Conservative": smoothingFilter = new ConservativeSmoothing(); break;
case "Adaptive": smoothingFilter = new AdaptiveSmoothing(); break;
case "Bilateral": smoothingFilter = new BilateralSmoothing(); break;
}
Bitmap smoothBitmap = smoothingFilter != null?smoothingFilter.Apply(grayscaleBitmap) : grayscaleBitmap;
IFilter edgeFilter = null;
switch (_edgeMode)
{
case "Homogenity": edgeFilter = new HomogenityEdgeDetector(); break;
case "Difference": edgeFilter = new DifferenceEdgeDetector(); break;
case "Sobel": edgeFilter = new SobelEdgeDetector(); break;
case "Canny": edgeFilter = new CannyEdgeDetector(); break;
}
Bitmap edgeBitmap = edgeFilter != null?edgeFilter.Apply(smoothBitmap) : smoothBitmap;
IFilter threshholdFilter = new Threshold(_threshold);
Bitmap thresholdBitmap = _threshold == 0 ? edgeBitmap : threshholdFilter.Apply(edgeBitmap);
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = _minHeight;
blobCounter.MinWidth = _minWidth;
blobCounter.ProcessImage(thresholdBitmap);
Blob[] blobs = blobCounter.GetObjectsInformation();
Bitmap outputBitmap = new Bitmap(thresholdBitmap.Width, thresholdBitmap.Height, PixelFormat.Format24bppRgb);
Graphics bitmapGraphics = Graphics.FromImage(outputBitmap);
Bitmap inputBitmap = null;
switch (_drawMode)
{
case "Original": inputBitmap = bitmap; break;
case "Grayscale": inputBitmap = grayscaleBitmap; break;
case "Smooth": inputBitmap = smoothBitmap; break;
case "Edge": inputBitmap = edgeBitmap; break;
case "Threshold": inputBitmap = thresholdBitmap; break;
}
if (inputBitmap != null)
{
bitmapGraphics.DrawImage(inputBitmap, 0, 0);
}
Pen nonConvexPen = new Pen(Color.Red, 2);
Pen nonRectPen = new Pen(Color.Orange, 2);
Pen cardPen = new Pen(Color.Blue, 2);
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
List <IntPoint> cardPositions = new List <IntPoint>();
for (int i = 0; i < blobs.Length; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners;
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if ((subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rectangle) && corners.Count == 4)
{
// Check if its sideways, if so rearrange the corners so it's vertical.
RearrangeCorners(corners);
// Prevent detecting the same card twice by comparing distance against other detected cards.
bool sameCard = false;
foreach (IntPoint point in cardPositions)
{
if (corners[0].DistanceTo(point) < _minDistance)
{
sameCard = true;
break;
}
}
if (sameCard)
{
continue;
}
// Hack to prevent it from detecting smaller sections of the card instead of the whole card.
if (GetArea(corners) < _minArea)
{
continue;
}
cardPositions.Add(corners[0]);
bitmapGraphics.DrawPolygon(cardPen, ToPointsArray(corners));
}
else
{
foreach (IntPoint point in edgePoints.Take(300))
{
bitmapGraphics.DrawEllipse(nonRectPen, point.X, point.Y, 1, 1);
}
}
}
else
{
foreach (IntPoint point in edgePoints.Take(300))
{
bitmapGraphics.DrawEllipse(nonConvexPen, point.X, point.Y, 1, 1);
}
}
}
bitmapGraphics.Dispose();
nonConvexPen.Dispose();
nonRectPen.Dispose();
cardPen.Dispose();
return(outputBitmap);
}
