private string reconhecerCaptcha(Image img) { Bitmap imagem = new Bitmap(img); imagem = imagem.Clone(new Rectangle(0, 0, img.Width, img.Height), System.Drawing.Imaging.PixelFormat.Format24bppRgb); Erosion erosion = new Erosion(); Dilatation dilatation = new Dilatation(); Invert inverter = new Invert(); ColorFiltering cor = new ColorFiltering(); cor.Blue = new AForge.IntRange(200, 255); cor.Red = new AForge.IntRange(200, 255); cor.Green = new AForge.IntRange(200, 255); Opening open = new Opening(); BlobsFiltering bc = new BlobsFiltering(); Closing close = new Closing(); GaussianSharpen gs = new GaussianSharpen(); ContrastCorrection cc = new ContrastCorrection(); bc.MinHeight = 10; FiltersSequence seq = new FiltersSequence(gs, inverter, open, inverter, bc, inverter, open, cc, cor, bc, inverter); pictureBox.Image = seq.Apply(imagem); string reconhecido = OCR((Bitmap)pictureBox.Image); return reconhecido; }
public void ApplyInPlace(Bitmap bmp) { if (Invert) { Invert invertF = new Invert(); invertF.ApplyInPlace(bmp); } Color c = Scale(DarkestColor, BrightestColor, Brightness); ; LevelsLinear levelsF = new LevelsLinear(); if (Invert) { levelsF.Input = new IntRange(0, (int)(255 * TextDarken)); } else { levelsF.Input = new IntRange(255 - (int)(255 * TextDarken), 255); } levelsF.OutRed = new IntRange(0, c.R); levelsF.OutGreen = new IntRange(0, c.G); levelsF.OutBlue = new IntRange(0, c.B); levelsF.ApplyInPlace(bmp); }
Bitmap prcessImageContourCenterLine(string filename) { Merge filter = new Merge(processImageCenterline(filename)); Bitmap resultImage = filter.Apply(processImageContour(filename)); Invert filterInvert = new Invert(); filterInvert.ApplyInPlace(resultImage); return resultImage; }
/// <summary> /// Process the filter on the specified image. /// </summary> /// /// <param name="image">Source image data.</param> /// protected override unsafe void ProcessFilter(UnmanagedImage image) { var width = image.Width; var height = image.Height; // 1 - invert the source image var invertFilter = new Invert( ); var invertedImage = invertFilter.Apply(image); // 2 - use blob counter to find holes (they are white objects now on the inverted image) var blobCounter = new BlobCounter( ); blobCounter.ProcessImage(invertedImage); var blobs = blobCounter.GetObjectsInformation( ); // 3 - check all blobs and determine which should be filtered var newObjectColors = new byte[blobs.Length + 1]; newObjectColors[0] = 255; // don't touch the objects, which have 0 ID for (int i = 0, n = blobs.Length; i < n; i++) { var blob = blobs[i]; if ((blob.Rectangle.Left == 0) || (blob.Rectangle.Top == 0) || (blob.Rectangle.Right == width) || (blob.Rectangle.Bottom == height)) { newObjectColors[blob.ID] = 0; } else { if (((this.coupledSizeFiltering) && (blob.Rectangle.Width <= this.maxHoleWidth) && (blob.Rectangle.Height <= this.maxHoleHeight)) | ((!this.coupledSizeFiltering) && ((blob.Rectangle.Width <= this.maxHoleWidth) || (blob.Rectangle.Height <= this.maxHoleHeight)))) { newObjectColors[blob.ID] = 255; } else { newObjectColors[blob.ID] = 0; } } } // 4 - process the source image image and fill holes var ptr = (byte *)image.ImageData.ToPointer( ); var offset = image.Stride - width; var objectLabels = blobCounter.ObjectLabels; for (int y = 0, i = 0; y < height; y++) { for (var x = 0; x < width; x++, i++, ptr++) { *ptr = newObjectColors[objectLabels[i]]; } ptr += offset; } }
/// <summary> /// Process the filter on the specified image. /// </summary> /// /// <param name="image">Source image data.</param> /// protected override unsafe void ProcessFilter(UnmanagedImage image) { int width = image.Width; int height = image.Height; // 1 - invert the source image Invert invertFilter = new Invert(); UnmanagedImage invertedImage = invertFilter.Apply(image); // 2 - use blob counter to find holes (they are white objects now on the inverted image) BlobCounter blobCounter = new BlobCounter(); blobCounter.ProcessImage(invertedImage); Blob[] blobs = blobCounter.GetObjectsInformation(); // 3 - check all blobs and determine which should be filtered byte[] newObjectColors = new byte[blobs.Length + 1]; newObjectColors[0] = 255; // don't touch the objects, which have 0 ID for (int i = 0, n = blobs.Length; i < n; i++) { Blob blob = blobs[i]; if ((blob.Rectangle.Left == 0) || (blob.Rectangle.Top == 0) || (blob.Rectangle.Right == width) || (blob.Rectangle.Bottom == height)) { newObjectColors[blob.ID] = 0; // background image } else { if (blob.Area <= maxArea) { newObjectColors[blob.ID] = 255; // fill hole, set to bright 255 NumFilled++; AreaFilled += blob.Area; } else { newObjectColors[blob.ID] = 0; // do no fill, remain dark zero NumUnfilled++; AreaUnfilled += blob.Area; } } } // 4 - process the source image image and fill holes byte *ptr = (byte *)image.ImageData.ToPointer(); int offset = image.Stride - width; int[] objectLabels = blobCounter.ObjectLabels; for (int y = 0, i = 0; y < height; y++) { for (int x = 0; x < width; x++, i++, ptr++) { *ptr = newObjectColors[objectLabels[i]]; } ptr += offset; } }
public Bitmap Adelgazar() { Invert ivert = new Invert(); imagen = ivert.Apply(imagen); FiltersSequence filterSequence = new FiltersSequence(); filterSequence.Add(new HitAndMiss( new short[,] { { 0, 0, 0 }, { -1, 1, -1 }, { 1, 1, 1 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { -1, 0, 0 }, { 1, 1, 0 }, { -1, 1, -1 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { 1, -1, 0 }, { 1, 1, 0 }, { 1, -1, 0 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { -1, 1, -1 }, { 1, 1, 0 }, { -1, 0, 0 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { 1, 1, 1 }, { -1, 1, -1 }, { 0, 0, 0 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { -1, 1, -1 }, { 0, 1, 1 }, { 0, 0, -1 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { 0, -1, 1 }, { 0, 1, 1 }, { 0, -1, 1 } }, HitAndMiss.Modes.Thinning)); filterSequence.Add(new HitAndMiss( new short[,] { { 0, 0, -1 }, { 0, 1, 1 }, { -1, 1, -1 } }, HitAndMiss.Modes.Thinning)); FilterIterator filterIterator = new FilterIterator(filterSequence, 15); imagen = filterIterator.Apply(imagen); imagen = ivert.Apply(imagen); return imagen; }
private Bitmap filter() { Bitmap filtered_image; AForge.Imaging.Filters.Grayscale gr = new AForge.Imaging.Filters.Grayscale(0.2125, 0.7154, 0.0721); AForge.Imaging.Filters.Threshold th = new AForge.Imaging.Filters.Threshold(100); AForge.Imaging.Filters.Invert invert = new AForge.Imaging.Filters.Invert(); filtered_image = gr.Apply(scanned_image); filtered_image = invert.Apply(filtered_image); filtered_image = th.Apply(filtered_image); return filtered_image; }
private Bitmap filter() { Bitmap filtered_image; AForge.Imaging.Filters.Grayscale gr = new AForge.Imaging.Filters.Grayscale(0.2125, 0.7154, 0.0721); AForge.Imaging.Filters.Threshold th = new AForge.Imaging.Filters.Threshold(100); AForge.Imaging.Filters.Invert invert = new AForge.Imaging.Filters.Invert(); filtered_image = gr.Apply(scanned_image); filtered_image = invert.Apply(filtered_image); filtered_image = th.Apply(filtered_image); return(filtered_image); }
public static IEnumerable<Blob> GetBlobs(Bitmap input, BlobCounterBase counter) { AForge.Imaging.Filters.Invert inv = new AForge.Imaging.Filters.Invert(); if (!IsInvertedColor(input)) { inv.ApplyInPlace(input); } counter.ProcessImage(input); return counter.GetObjects(input, false); }
protected override unsafe void ProcessFilter(UnmanagedImage image) { int width = image.Width; int height = image.Height; UnmanagedImage image2 = new Invert().Apply(image); BlobCounter counter = new BlobCounter(); counter.ProcessImage(image2); Blob[] objectsInformation = counter.GetObjectsInformation(); byte[] buffer = new byte[objectsInformation.Length + 1]; buffer[0] = 0xff; int index = 0; int length = objectsInformation.Length; while (index < length) { Blob blob = objectsInformation[index]; if (((blob.Rectangle.Left == 0) || (blob.Rectangle.Top == 0)) || ((blob.Rectangle.Right == width) || (blob.Rectangle.Bottom == height))) { buffer[blob.ID] = 0; } else if (((this.coupledSizeFiltering && (blob.Rectangle.Width <= this.maxHoleWidth)) && (blob.Rectangle.Height <= this.maxHoleHeight)) | (!this.coupledSizeFiltering && ((blob.Rectangle.Width <= this.maxHoleWidth) || (blob.Rectangle.Height <= this.maxHoleHeight)))) { buffer[blob.ID] = 0xff; } else { buffer[blob.ID] = 0; } index++; } byte *numPtr = (byte *)image.ImageData.ToPointer(); int num5 = image.Stride - width; int[] objectLabels = counter.ObjectLabels; int num6 = 0; int num7 = 0; while (num6 < height) { int num8 = 0; while (num8 < width) { numPtr[0] = buffer[objectLabels[num7]]; num8++; num7++; numPtr++; } numPtr += num5; num6++; } }
protected unsafe override void ProcessFilter(UnmanagedImage image) { int width = image.Width; int height = image.Height; Invert invert = new Invert(); UnmanagedImage image2 = invert.Apply(image); BlobCounter blobCounter = new BlobCounter(); blobCounter.ProcessImage(image2); Blob[] objectsInformation = blobCounter.GetObjectsInformation(); byte[] array = new byte[objectsInformation.Length + 1]; array[0] = byte.MaxValue; int i = 0; for (int num = objectsInformation.Length; i < num; i++) { Blob blob = objectsInformation[i]; if (blob.Rectangle.Left == 0 || blob.Rectangle.Top == 0 || blob.Rectangle.Right == width || blob.Rectangle.Bottom == height) { array[blob.ID] = 0; } else if ((coupledSizeFiltering && blob.Rectangle.Width <= maxHoleWidth && blob.Rectangle.Height <= maxHoleHeight) | (!coupledSizeFiltering && (blob.Rectangle.Width <= maxHoleWidth || blob.Rectangle.Height <= maxHoleHeight))) { array[blob.ID] = byte.MaxValue; } else { array[blob.ID] = 0; } } byte *ptr = (byte *)image.ImageData.ToPointer(); int num2 = image.Stride - width; int[] objectLabels = blobCounter.ObjectLabels; int j = 0; int num3 = 0; for (; j < height; j++) { int num4 = 0; while (num4 < width) { *ptr = array[objectLabels[num3]]; num4++; num3++; ptr++; } ptr += num2; } }
public IEnumerable<Bitmap> Apply(Bitmap bitmap) { // assuming scanned background is white we need to invert for the algo to work var copy = new Invert().Apply(bitmap); copy = EnsureGrayscale(copy); new Threshold { ThresholdValue = 25 }.ApplyInPlace(copy); new FillHoles().ApplyInPlace(copy); var blobCounter = new BlobCounter { // set filtering options FilterBlobs = true, MinWidth = 50, MinHeight = 50, }; blobCounter.ProcessImage(copy); var blobs = blobCounter.GetObjectsInformation(); if (blobs.Any()) { var invertedOriginal = new Invert().Apply(bitmap); foreach (var blob in blobs) { // use inverted source to ensure correct edge colors blobCounter.ExtractBlobsImage(invertedOriginal, blob, false); var blobImage = blob.Image.ToManagedImage(); // straighten var angle = new DocumentSkewChecker().GetSkewAngle(EnsureGrayscale(blobImage)); var rotationFilter = new RotateBilinear(-angle) { FillColor = Color.Black }; blobImage = rotationFilter.Apply(blobImage); // crop blobImage = new ExtractBiggestBlob().Apply(blobImage); new Invert().ApplyInPlace(blobImage); yield return blobImage; } } else { yield return bitmap; } }
Blob[] DetectBlobs(Bitmap bmp) { Invert filter = new Invert(); filter.ApplyInPlace(bmp); BlobCounter bc = new BlobCounter(); bc.BackgroundThreshold = Color.FromArgb(8, 8, 8); bc.BlobsFilter = new BlobsFilter(bmp.Size); bc.FilterBlobs = true; bc.ProcessImage(bmp); // Revert back filter.ApplyInPlace(bmp); return bc.GetObjectsInformation(); }
protected override void doSegment(Bitmap image, out int[,] rows, out int[,] cols) { //Adaptively threshold the image to give us a binary result Bitmap thresholded = FilterCombinations.AdaptiveThreshold(image); //Invert the image, to give white foreground and black background (as is required by the AForge.NET Blob Detection system) Invert invertFilter = new Invert(); invertFilter.ApplyInPlace(thresholded); //Perform Blob Recognition Blob[] blobs = blobRecognition(thresholded); //Get character blobs (filter out the non-characters) List<Blob> blobChars = filterBlobs(blobs); //Determine the row & col positions from the char blobs findRowsAndCols(blobChars, out rows, out cols); //Clean up thresholded.Dispose(); }
public double GetTemperature() { var temp = 0.0; var image = Image.FromFile(filename); var grayscale = new Grayscale(0.2125, 0.7154, 0.0721); image = grayscale.Apply(image); var invert = new Invert(); image = invert.Apply(image); var stats = new ImageStatistics(image); var levelsLinear = new LevelsLinear { InGray = stats.Gray.GetRange(2.90) }; image = levelsLinear.Apply(image); var contrast = new ContrastStretch(); image = contrast.Apply(image); var erosion = new Erosion(); image = erosion.Apply(image); var blur = new GaussianBlur(2, 3); image = blur.Apply(image); var threshold = new Threshold(79); image = threshold.Apply(image); image.Save(processedFileName, System.Drawing.Imaging.ImageFormat.Jpeg); image.Dispose(); var text = Recognise(); double.TryParse(text.Replace(',', '.'), out temp); return temp; }
private void Effect() { IFilter imgeFilter = new BurkesDithering(); Bitmap bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnCommon.Image = bitimg; imgeFilter = new GrayscaleBT709(); btnGray.Image = new Bitmap(imgeFilter.Apply(img), 90, 111); imgeFilter = new Sepia(); bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnSeperia.Image = bitimg; imgeFilter = new Invert(); bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnInvert.Image = bitimg; imgeFilter = new Blur(); bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnBlur.Image = bitimg; imgeFilter = new Texturer(new AForge.Imaging.Textures.MarbleTexture(10, 11), 0.7f, 0.3f); bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnJitter.Image = bitimg; imgeFilter = new ChannelFiltering(new IntRange(0, 0), new IntRange(0, 255), new IntRange(0, 255)); bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnCyan.Image = bitimg; imgeFilter = new YCbCrExtractChannel(AForge.Imaging.YCbCr.CrIndex); bitimg = new Bitmap(imgeFilter.Apply(img), 90, 111); btnBlackWhite.Image = bitimg; }
// 반전 public static Bitmap invert(Bitmap source) { Bitmap tmp = (Bitmap)source; // 중요! 한번 이미지 처리가 끝난 비트맵 source 는 clone 함수로 보내기 전에 다시 한번 (Bitmap) 처리 해줘야함, 이유는 잘 모르겠음 // convert to 24 bits per pixel source = ImageProcess.Clone(tmp, PixelFormat.Format24bppRgb); // delete old image tmp.Dispose(); Invert invertfilter = new Invert(); invertfilter.ApplyInPlace(source); return source; }
public Form1() { InitializeComponent(); Bitmap image = new Bitmap(@"C:\Images\bitmap.bmp"); Invert filter = new Invert(); // apply the filter filter.ApplyInPlace(image); var shapeChecker = new SimpleShapeChecker(); BlobCounter blobCounter = new BlobCounter(); // process input image blobCounter.ProcessImage(image); // get information about detected objects Blob[] blobs = blobCounter.GetObjectsInformation(); var squares = 0; Graphics g = Graphics.FromImage(image); Pen bluePen = new Pen(Color.Yellow, 2); Pen redpen = new Pen(Color.Red, 2); var quads = blobs.Where(x => shapeChecker.IsQuadrilateral(blobCounter.GetBlobsEdgePoints(x))); var largest = quads.OrderByDescending(x => x.Area).First(); List<IntPoint> largestedgePoints = blobCounter.GetBlobsEdgePoints(largest); List<IntPoint> largestcorners; shapeChecker.IsQuadrilateral(largestedgePoints, out largestcorners); var largestpoints = largestcorners.Select(x => new PointF(x.X, x.Y)).ToArray(); //g.DrawPolygon(redpen, largestpoints); for (int i = 0, n = blobs.Length; i < n; i++) { List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List<IntPoint> corners; Point center; float radius; if(blobs[i].Area < 150) continue; if (shapeChecker.IsQuadrilateral(edgePoints, out corners)) { var a = corners.Select(x => new IntPoint(x.X, x.Y)).ToList(); var shape = shapeChecker.CheckPolygonSubType(a); if (shape == PolygonSubType.Square || shape == PolygonSubType.Rectangle) { if (corners.Min(x => x.Y) < largestcorners.Min(x => x.Y) || corners.Min(x => x.Y) > largestcorners.Max(x => x.Y)) { var points = corners.Select(x => new PointF(x.X, x.Y)).ToArray(); g.DrawPolygon(bluePen, points); } } } else if (shapeChecker.IsCircle(edgePoints, out center, out radius)) { //g.DrawEllipse(bluePen, // (int)(center.X - radius), // (int)(center.Y - radius), // (int)(radius * 2), // (int)(radius * 2)); } } pictureBox1.Image = image; bluePen.Dispose(); g.Dispose(); }
public static Bitmap Negative(this Bitmap source) { var filter = new Invert(); filter.ApplyInPlace(source); return source; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object"/> class. /// </summary> /// <remarks></remarks> public TileOCR(string trainingPath) { classifier = new KNearestClassifier(1, Metric.EuclideanDistance, WeightMode.InverseDistance); training = LoadInstancesFromBitmaps(trainingPath); classifier.Train(training); results = new List<OCRResult>(); grayscale = new Grayscale(0, 0.85, 0.15); invert = new Invert(); resize = new ResizeNearestNeighbor(32, 32); floodFill = new PointedColorFloodFill(Color.Black); dilate = new BinaryDilatation3x3(); blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinWidth = 4; blobCounter.MinHeight = 14; blobCounter.MaxWidth = 30; blobCounter.MaxHeight = 30; blobCounter.ObjectsOrder = ObjectsOrder.XY; threshold = new BradleyLocalThresholding(); threshold.PixelBrightnessDifferenceLimit = 0; //Threshold.WindowSize = 20; threshold.WindowSize = 24; }
// ========================================================= private void InvertFunct(ref Bitmap frame) { Invert filter = new Invert(); filter.ApplyInPlace(frame); }
public static Bitmap ApplyInvert(Bitmap pBitmap) { var filter = new Invert(); return filter.Apply(pBitmap); }
private static Bitmap invertColors(Bitmap bmp) { Invert filter = new Invert(); filter.ApplyInPlace(bmp); return bmp; }
private void ProcessImage() { m_selectedBlobs.Clear(); pictureBox1.Controls.Clear(); pictureBox1.Image = null; if (m_original != null) m_original.Dispose(); if (m_binarized != null) m_binarized.Dispose(); m_original = new Bitmap(txtFile.Text); // create grayscale filter (BT709) Grayscale filter = new Grayscale(0.2125, 0.7154, 0.0721); m_binarized = filter.Apply(m_original); // Binarize Picture. Threshold bin = new Threshold((int)txtBinThershold.Value); bin.ApplyInPlace(m_binarized); // create filter Invert inv = new Invert(); inv.ApplyInPlace(m_binarized); // create an instance of blob counter algorithm BlobCounter bc = new BlobCounter(); bc.ObjectsOrder = ObjectsOrder.XY; bc.ProcessImage(m_binarized); Rectangle[] blobsRect = bc.GetObjectsRectangles(); Dictionary<int, List<Rectangle>> orderedBlobs = ReorderBlobs(blobsRect); foreach (KeyValuePair<int, List<Rectangle>> orderedBlob in orderedBlobs) { orderedBlob.Value.ForEach(r => AddBlobPanel(orderedBlob.Key, r)); } pictureBox1.Image = chkShowBinarize.Checked ? m_binarized : m_original; pictureBox1.Invalidate(); }
// 색상 반전 private void button28_Click(object sender, EventArgs e) { Bitmap source = Global.source; Bitmap tmp = source; // convert to 24 bits per pixel source = imageProcess.Clone(tmp, PixelFormat.Format24bppRgb); // delete old image tmp.Dispose(); Invert invertfilter = new Invert(); invertfilter.ApplyInPlace(source); Global.source = source; pictureBox1.Image = Global.source; pictureBox1.Refresh(); //string path = calculator.CreateFileCheck("C:\\Program Files\\PLOCR\\prescription.png"); //pictureBox1.Image.Save(path); }
/// <summary> /// Process the filter on the specified image. /// </summary> /// /// <param name="image">Source image data.</param> /// protected override unsafe void ProcessFilter( UnmanagedImage image ) { int width = image.Width; int height = image.Height; // 1 - invert the source image Invert invertFilter = new Invert( ); UnmanagedImage invertedImage = invertFilter.Apply( image ); // 2 - use blob counter to find holes (they are white objects now on the inverted image) BlobCounter blobCounter = new BlobCounter( ); blobCounter.ProcessImage( invertedImage ); Blob[] blobs = blobCounter.GetObjectsInformation( ); // 3 - check all blobs and determine which should be filtered byte[] newObjectColors = new byte[blobs.Length + 1]; newObjectColors[0] = 255; // don't touch the objects, which have 0 ID for ( int i = 0, n = blobs.Length; i < n; i++ ) { Blob blob = blobs[i]; if ( ( blob.Rectangle.Left == 0 ) || ( blob.Rectangle.Top == 0 ) || ( blob.Rectangle.Right == width ) || ( blob.Rectangle.Bottom == height ) ) { newObjectColors[blob.ID] = 0; } else { if ( ( ( coupledSizeFiltering ) && ( blob.Rectangle.Width <= maxHoleWidth ) && ( blob.Rectangle.Height <= maxHoleHeight ) ) | ( ( !coupledSizeFiltering ) && ( ( blob.Rectangle.Width <= maxHoleWidth ) || ( blob.Rectangle.Height <= maxHoleHeight ) ) ) ) { newObjectColors[blob.ID] = 255; } else { newObjectColors[blob.ID] = 0; } } } // 4 - process the source image image and fill holes byte* ptr = (byte*) image.ImageData.ToPointer( ); int offset = image.Stride - width; int[] objectLabels = blobCounter.ObjectLabels; for ( int y = 0, i = 0; y < height; y++ ) { for ( int x = 0; x < width; x++, i++, ptr++ ) { *ptr = newObjectColors[objectLabels[i]]; } ptr += offset; } }
// ========================================================= private void InvertFunct(ref Bitmap frame, int par_int, double par_d, int par_R, int par_G, int par_B) { Invert filter = new Invert(); filter.ApplyInPlace(frame); }
/// <summary> /// Добавляет несколько несколько ячеек в ответ начиная с первой /// </summary> /// <param name="image">Ссылка ни изображение</param> /// <param name="CellsCount">Количество ячеек для добавления в ответ</param> /// <param name="FirstCellDistanses">Коллекция дистанций между первой ячейкой и маркерами</param> /// <param name="intercentresdistX">Расстояние между центрами ячеек</param> /// <param name="Width">Длина ячеек</param> /// <param name="Height">Высота ячеек</param> public void IntelligentAdd(Bitmap image, int CellsCount, Distances FirstCellDistanses, int intercentresdistX, int Width, int Height) { int maxslice = intercentresdistX/2; //находим первую доступную дистанцию Distance d = FirstCellDistanses.FindOneGood(); int maxWidth = Width + Convert.ToInt16(Width/2); int maxHeigth = Height + Convert.ToInt16(Height/2); //увеличиваем ячейки this.Add(image,CellsCount,FirstCellDistanses,intercentresdistX,maxWidth,maxHeigth); BitmapData data = image.LockBits(_cells[0].Rect, ImageLockMode.ReadWrite, image.PixelFormat); BlobCounter blobCounter = new BlobCounter(); Invert invertfilter = new Invert(); invertfilter.ApplyInPlace(data); blobCounter.ProcessImage(data); Blob[] blobs = blobCounter.GetObjectsInformation(); if (blobs.Length != 0) { int maxar = 0; int b = 0; for (int i = 0; i < blobs.Count(); i++) { if (blobs[i].Area > maxar) { maxar = blobs[i].Area; b = i; } } invertfilter.ApplyInPlace(data); System.Drawing.Point p = new System.Drawing.Point(_cells[0].CenterOfGravity.X - ((maxWidth / 2) - Convert.ToInt16(blobs[b].CenterOfGravity.X)), _cells[0].CenterOfGravity.Y - ((maxHeigth / 2) - Convert.ToInt16(blobs[b].CenterOfGravity.Y))); if (Math.Abs(_cells[0].CenterOfGravity.Y - p.Y) <= maxslice) { this.ReMeasure(p, intercentresdistX, Width, Height); } else { this.ReMeasure(_cells[0].CenterOfGravity, intercentresdistX, Width, Height); } } image.UnlockBits(data); }
private void btnEffectApply_Click(object sender, EventArgs e) { resizerControl.Visible = true; IFilter imgeFilter = default(IFilter); Button effect = (Button)sender; Bitmap imgEffect = img; if (effect.Name == "btnGray") { imgeFilter = new GrayscaleBT709(); } else if (effect.Name == "btnSeperia") { imgeFilter = new Sepia(); } else if (effect.Name == "btnInvert") { imgeFilter = new Invert(); } else if (effect.Name == "btnCommon") { imgeFilter = new BurkesDithering(); } else if (effect.Name == "btnBlur") { imgeFilter = new Blur(); } else if (effect.Name == "btnJitter") { imgeFilter = new Texturer(new AForge.Imaging.Textures.MarbleTexture(10, 11), 0.7f, 0.3f); } else if (effect.Name == "btnCyan") { imgeFilter = new ChannelFiltering(new IntRange(0, 0), new IntRange(0, 255), new IntRange(0, 255)); } else if (effect.Name == "btnBlackWhite") { imgeFilter = new YCbCrExtractChannel(AForge.Imaging.YCbCr.CrIndex); } imgEffect = imgeFilter.Apply(img); panelImage.BackgroundImage = imgEffect; //img = imgEffect; }
public ActionResult Index(string Data, int Smallest = 3, int Largest = 6, HttpPostedFileBase file = null) { string base64Image = null; if (file != null) { //try to determine data from posted file var bitmap = new Bitmap(file.InputStream); // lock image BitmapData bitmapData = bitmap.LockBits( new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); // step 1 - turn background to black var filter = new Invert(); filter.ApplyInPlace(bitmapData); ColorFiltering colorFilter = new ColorFiltering(); colorFilter.Red = new IntRange(0, 64); colorFilter.Green = new IntRange(0, 64); colorFilter.Blue = new IntRange(0, 64); colorFilter.FillOutsideRange = false; colorFilter.ApplyInPlace(bitmapData); // step 2 - locating objects BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 5; blobCounter.MinWidth = 5; blobCounter.ProcessImage(bitmapData); var blobs = blobCounter.GetObjectsInformation(); bitmap.UnlockBits(bitmapData); base64Image = bitmap.ToBase64(); // get information about detected objects var shapeChecker = new SimpleShapeChecker(); var letters = new List<Letter>(); int circleCount = 0; foreach ( var blob in blobs.ToArray() .OrderBy(b => b.Rectangle.Top) .ThenBy(b => b.Rectangle.Left) .ThenByDescending(b => b.Area)) { List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob); AForge.Point center; float radius; if (shapeChecker.IsCircle(edgePoints, out center, out radius)) { //Todo: filter on the largest radius * 90% to deal with resolutions if (radius < 40) continue; blobCounter.ExtractBlobsImage(bitmap, blob, false); var letter = blob.Image.ToManagedImage(true); var resizeFilter = new ResizeBilinear(150, 150); letter = resizeFilter.Apply(letter); var bwBitmap = new Bitmap(75, 75, PixelFormat.Format32bppArgb); for (int y = 40; y < 115; y++) { for (int x = 40; x < 115; x++) { var color = letter.GetPixel(x, y); if (color.Name == "ff000000") { bwBitmap.SetPixel(x - 40, y - 40, Color.Black); } else { bwBitmap.SetPixel(x - 40, y - 40, Color.White); } } } letters.Add(new Letter { L = TrainingData.GetBestGuess(bwBitmap), X = center.X, Y = center.Y, Radius = radius }); } } var minX = letters.Min(c => c.X); var maxX = letters.Max(c => c.X); var minY = letters.Min(c => c.Y); var maxY = letters.Max(c => c.Y); var smallestRadius = letters.Min(c => c.Radius); var numberOfItemsPerRow = (int)((maxX - minX)/ smallestRadius / 2); var numberOfItemsPerCol = (int)((maxY - minY) / smallestRadius / 2); var spaceBetweenPointsX = (maxX - minX)/numberOfItemsPerRow; var spaceBetweenPointsY = (maxY - minY) / numberOfItemsPerCol; var varianceDelta = smallestRadius*.05f; //allow 5% pixel float var puzzle = new StringBuilder(); for (var y = minY; y <= maxY; y += spaceBetweenPointsY) { for (var x = minX; x <= maxX; x += spaceBetweenPointsX) { var item = letters.FirstOrDefault(c => c.X > x - varianceDelta && c.X < x + varianceDelta && c.Y > y - varianceDelta && c.Y < y + varianceDelta); if (item != null) puzzle.Append(item.L); else puzzle.Append("_"); } puzzle.AppendLine(); } Data = puzzle.ToString(); } var solutions = SolvePuzzle(Data, Smallest, Largest); return View(new PuzzleModel { Data = Data, Largest = Largest, Smallest = Smallest, Solutions = solutions, Base64Image = base64Image }); }
public static Bitmap ToInvert(this Bitmap bitmap) { AForge.Imaging.Filters.Invert filter = new AForge.Imaging.Filters.Invert(); return(filter.Apply(AForge.Imaging.Image.Clone(bitmap, PixelFormat.Format24bppRgb))); }
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---------------- }
private void InvertImage() { Invert invertfilter = new Invert(); _markersimg = invertfilter.Apply(_recogimg); }
Bitmap denoise(Bitmap bmp, Size size) { Bitmap ivbmp = bmp.Clone() as Bitmap; Invert iv = new Invert(); iv.ApplyInPlace(ivbmp); BlobCounter bc = new BlobCounter(); bc.FilterBlobs = true; bc.MinWidth = bc.MinHeight = 0; bc.MaxWidth = size.Width; bc.MaxHeight = size.Height; bc.ProcessImage(ivbmp); Rectangle[] rects = bc.GetObjectsRectangles(); Bitmap tmp = new Bitmap(bmp); using (Graphics g = Graphics.FromImage(tmp)) //g.DrawRectangles(Pens.Red, rects); if (rects.Length > 0) g.FillRectangles(Brushes.White, rects); //iv.ApplyInPlace(tmp); return tmp; }
// ========================================================= private Bitmap TestAlgorithmFunct(Bitmap frame) { frame = Grayscale.CommonAlgorithms.RMY.Apply(frame); Invert filter = new Invert(); filter.ApplyInPlace(frame); return (frame); }
public static void Negative(this Bitmap image) { AForge.Imaging.Filters.Invert filter = new AForge.Imaging.Filters.Invert(); filter.ApplyInPlace(image); }
public static Bitmap Inverse(Bitmap img) { IFilter filter = new Invert(); return filter.Apply(img); }
private Bitmap ProcessImage(Bitmap bitmap) { ///CROP SYSTEM //if (cropx1 != 0 && cropy1 != 0 && cropx2 != 0 && cropy2 != 0 && Worker.selected_square != 0) //{ // Crop crop_filter = new Crop(new Rectangle(cropx1, cropy1, cropx2, cropy2)); // bitmap= crop_filter.Apply(bitmap); // Console.WriteLine(">Crop Cutter:> Cropped\n({0},{1}),({2},{3})", cropx1, cropy1, cropx2, cropy2); //} //if (Worker.selected_square == 0) //{ // Crop crop_filter = new Crop(new Rectangle(0, 0, bitmap.Width,bitmap.Height)); // bitmap = crop_filter.Apply(bitmap); // //Console.WriteLine(">Crop Cutter:> RESET"); //} //// step 2 - locating objects if (cropx1 == 0 && cropy1 == 0 && cropx2 == 0 && cropy2 == 0) { cropx1 = 0; cropy1 = 0; cropx2 = bitmap.Width; cropy2 = bitmap.Height; } Bitmap old = bitmap; Crop crop_filter = new Crop(new Rectangle(cropx1, cropy1, cropx2, cropy2)); bitmap = crop_filter.Apply(bitmap); // lock image BitmapData bitmapData = bitmap.LockBits( new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat); // ////invert // Invert inv = new Invert(); // // //apply the filter //inv.ApplyInPlace(bitmapData); //// create filter //HSLFiltering filter = new HSLFiltering(); //// set color ranges to keep //filter.Hue = new IntRange(90, 300); //filter.Saturation = new Range(0.0f, .5f); //filter.Luminance = new Range(0f, 1); //// apply the filter //filter.ApplyInPlace(bitmapData); //EuclideanColorFiltering filter = new EuclideanColorFiltering(); //// set center colol and radius //filter.CenterColor = new RGB(209, 206, 196); //filter.Radius = 150; //// apply the filter //filter.ApplyInPlace(bitmapData); //// create filter ChannelFiltering filter = new ChannelFiltering(); //// set channels' ranges to keep Invert inv = new Invert(); //// //apply the filter inv.ApplyInPlace(bitmapData); if (red_max > 255) { red_max = 255; Console.WriteLine("1THRESHOLD OVERIDE"); } if (blue_max > 255) { blue_max = 255; Console.WriteLine("2THRESHOLD OVERIDE"); } if (green_max > 255) { green_max = 255; Console.WriteLine("3THRESHOLD OVERIDE"); } if (red > 255) { red = 254; Console.WriteLine("4THRESHOLD OVERIDE"); } if (blue > 255) { blue = 254; Console.WriteLine("5THRESHOLD OVERIDE"); } if (green > 255) { green = 254; Console.WriteLine("6THRESHOLD OVERIDE"); } if (red < 0) { red = 1; Console.WriteLine("7THRESHOLD UNDERIDE"); } if (blue < 0) { blue = 1; Console.WriteLine("8THRESHOLD UNDERIDE"); } if (green < 0) { green = 1; Console.WriteLine("9THRESHOLD UNDERIDE"); } if (red_max < 0) { red_max = 255; Console.WriteLine("10THRESHOLD UNDERIDE"); } if (blue_max < 0) { blue_max = 255; Console.WriteLine("11THRESHOLD UNDERIDE"); } if (green_max < 0) { green_max = 255; Console.WriteLine("13THRESHOLD UNDERIDE"); } if (red_max < red) { Console.WriteLine("14THRESHOLD UNION ERROR"); red = 0; red_max = 255; } if (blue_max < blue) { blue = 0; Console.WriteLine("15THRESHOLD UNION ERROR"); blue_max = 255; } if (green_max < green) { green = 0; green_max = 255; Console.WriteLine("16THRESHOLD UNION ERROR"); } file.WriteLine("R: " + red + " R_M: " + red_max); file.WriteLine("G: " + green + " G_M: " + green_max); file.WriteLine("B: " + blue + " B_M: " + blue_max); file.WriteLine("EOE"); //file.Close(); filter.Red = new IntRange(red, red_max); filter.Green = new IntRange(green, green_max); filter.Blue = new IntRange(blue, blue_max); //// apply the filter filter.ApplyInPlace(bitmapData); ////invert //edge //CannyEdgeDetector edge_filter = new CannyEdgeDetector(); //// apply the filter //edge_filter.ApplyInPlace(bitmapData); BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = blob_size * 3; blobCounter.MinWidth = blob_size * 4; blobCounter.ProcessImage(bitmapData); Blob[] blobs = blobCounter.GetObjectsInformation(); bitmap.UnlockBits(bitmapData); // step 3 - check objects' type and highlight SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); Graphics g = Graphics.FromImage(bitmap); Pen yellowPen = new Pen(Color.Yellow, 2); // circles Pen redPen = new Pen(Color.Red, 2); // quadrilateral Pen brownPen = new Pen(Color.Brown, 2); // quadrilateral with known sub-type Pen greenPen = new Pen(Color.Green, 2); // known triangle Pen bluePen = new Pen(Color.Blue, 2); // triangle double curdist = 0; double leastdist = 100; //List<IntPoint> bestcorn;//promoted to super for (int i = 0, n = blobs.Length; i < n; i++) { List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List<IntPoint> corners; // the list of x,y coordinates. corners(list)->corner(intpoint)->[x,y] // is triangle or quadrilateral if (shapeChecker.IsConvexPolygon(edgePoints, out corners)) { cornide = corners; // get sub-type PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners); Pen pen; if (subType == PolygonSubType.Rectangle || subType == PolygonSubType.Trapezoid || subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rhombus || subType == PolygonSubType.Square || subType == PolygonSubType.Unknown) { if (corners.Count == 4) { pen = redPen; IntPoint[] array_of_corners = corners.ToArray();//array_of_corners is now an array of corners if (((732 / avdisty(array_of_corners)) + .222) < ((989 / avdistx(array_of_corners)) + 3.37)) { curdist = ((732 / avdisty(array_of_corners)) + .222);//from our graph } else { curdist = ((989 / avdistx(array_of_corners)) + 3.37);//from our graph } //if (Worker.selected_square == 1) //{ // Console.WriteLine("called\n"); // IntPoint one = array_of_corners[0]; // IntPoint two = array_of_corners[3]; // cropx1 = one.X - 5; // cropy1 = one.Y - 5; // cropx2 = two.X + 5; // cropy2 = two.Y + 5; //} //else if (i == Worker.selected_square - 1 && Worker.selected_square != 1) //{ // Console.WriteLine("called\n"); // IntPoint one = array_of_corners[0]; // IntPoint two = array_of_corners[3]; // cropx1 = one.X - 5; // cropy1 = one.Y - 5; // cropx2 = two.X + 5; // cropy2 = two.Y + 5; //} //if (Worker.selected_square == 0) //{ // cropx1 = 0; // cropy1 = 0; // cropx2 = 0; // cropy2 = 0; //} if (Worker.selected_square == 0)//PREDATOR VISION { if (curdist < leastdist) { // Console.WriteLine((abs(array_of_corners[0].Y - array_of_corners[1].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X))); //if ((abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) < 1.25 && (abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) > .5) if (true) { leastdist = curdist; if (leastdist < 55 && leastdist > 2) { double angle = (array_of_corners[0].X + array_of_corners[3].X) / 2; Console.WriteLine("0: " + array_of_corners[0].X + " 1: " + array_of_corners[1].X + " 2: " + array_of_corners[2].X + " 3: " + array_of_corners[3].X); Server.SetData(((array_of_corners[0].X + array_of_corners[1].X) / 2), 1); Console.WriteLine("PREDATOR: " + Server.GetData(1)); Console.WriteLine(leastdist); Server.SetData(leastdist, 0); bestcorn = corners;//superify? //g.DrawPolygon(pen, ToPointsArray(bestcorn));//leave here as a comment IntPoint ones = array_of_corners[0]; PointF string_draw = new PointF(ones.X, ones.Y); SolidBrush tbrush = new SolidBrush(Color.Red); try { if (string_draw.X != 0 && string_draw.Y != 0) { g.DrawString(n.ToString(), this.Font, tbrush, string_draw); } } catch (Exception e) { Console.WriteLine("{0} in {1} ({2},{3})", e.Message, e.StackTrace, string_draw.X, string_draw.Y); } } } } try { Graphics global_graphics_predator = Graphics.FromImage(bitmap); Pen penc = new Pen(Color.YellowGreen, 2); //g.DrawPolygon(penc, ToPointsArray(bestcorn)); global_graphics_predator.DrawPolygon(penc, ToPointsArray(bestcorn)); global_graphics_predator.DrawLine(penc, new System.Drawing.Point(320, 1), new System.Drawing.Point(320, 479)); //bitmap = global_bitmap; } catch (Exception e) { } yellowPen.Dispose(); redPen.Dispose(); greenPen.Dispose(); bluePen.Dispose(); brownPen.Dispose(); g.Dispose(); return bitmap; } else { int sel_least_dist = Worker.selected_square; sel_least_dist *= 3;//threefeet sel_least_dist -= 1; int sel_max_dist = sel_least_dist + 5; Console.WriteLine(sel_least_dist); Console.WriteLine(sel_max_dist); //Console.WriteLine(sel_least_dist + " " + sel_max_dist); if (curdist < leastdist && curdist > sel_least_dist && curdist < sel_max_dist) { // Console.WriteLine((abs(array_of_corners[0].Y - array_of_corners[1].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X))); //if ((abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) < 1.25 && (abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) > .5) if (true)//todo { leastdist = curdist; if (leastdist < 55 && leastdist > 2) { // Console.WriteLine("0: " + array_of_corners[0].X + " 1: " + array_of_corners[1].X + " 2: " + array_of_corners[2].X + " 3: " + array_of_corners[3].X); Server.SetData(((array_of_corners[0].X + array_of_corners[1].X) / 2), 1); Console.WriteLine(Server.GetData(1)); //Console.WriteLine(leastdist); Server.SetData(leastdist, 0); bestcorn = corners;//superify? //g.DrawPolygon(pen, ToPointsArray(bestcorn));//leave here as a comment IntPoint ones = array_of_corners[0]; PointF string_draw = new PointF(ones.X, ones.Y); SolidBrush tbrush = new SolidBrush(Color.Red); try { if (string_draw.X != 0 && string_draw.Y != 0) { g.DrawString(n.ToString(), this.Font, tbrush, string_draw); // glob.DrawLine(penc, new System.Drawing.Point(10, 10), new System.Drawing.Point(20, 20)); //g.DrawLine(pen, new System.Drawing.Point(10, 10), new System.Drawing.Point(20, 20)); } } catch (Exception e) { Console.WriteLine("{0} in {1} ({2},{3})", e.Message, e.StackTrace, string_draw.X, string_draw.Y); } } } } } //pen = (corners.Count == 4) ? redPen : bluePen; }//TODO get rid of anything that ISNT drawn, eg corner } //else //{ // pen = (corners.Count == 4) ? brownPen : greenPen; //} } } //Console.WriteLine(leastdist); how dod oyo //double leastdist = 0; //for (int i = 0, n = blobs.Length; i < n; i++) //{ // try // { // List<IntPoint> filterlist; // filterlist = cornide; // IntPoint[] filter_corners = filterlist.ToArray(); // double currentdist = 0; // for (int corner_count = 0; corner_count < filter_corners.Length; corner_count++) // { // IntPoint one_f = filter_corners[corner_count]; // corner_count++; // IntPoint two_f = filter_corners[corner_count]; // corner_count++; // IntPoint three_f = filter_corners[corner_count]; // corner_count++; // IntPoint four_f = filter_corners[corner_count]; // double y_average_a = ((double)one_f.Y + (double)two_f.Y) / 2; // double y_average_b = ((double)three_f.Y + (double)four_f.Y) / 2; // double averaged_dist = y_average_b - y_average_a; // currentdist = ((732 / averaged_dist) + .222);//from our graph // if (currentdist <= leastdist) // { // leastdist = currentdist; // Pen pencil = redPen; // g.DrawPolygon(pencil, ToPointsArray(filterlist)); // } // } // } // catch // { // //do nothING // } //} //Console.WriteLine(leastdist); try { Graphics global_graphics = Graphics.FromImage(global_bitmap); Pen penc = new Pen(Color.YellowGreen, 2); { //g.DrawPolygon(penc, ToPointsArray(bestcorn)); global_graphics.DrawPolygon(penc, ToPointsArray(bestcorn)); global_graphics.DrawLine(penc, new System.Drawing.Point(320, 1), new System.Drawing.Point(320, 479)); bitmap = global_bitmap; } } catch (Exception e) { } try { g.DrawLine(redPen, 220, 1, 220, 100); } catch (Exception e) { Console.WriteLine(e.StackTrace); Console.WriteLine(e.InnerException); } yellowPen.Dispose(); redPen.Dispose(); greenPen.Dispose(); bluePen.Dispose(); brownPen.Dispose(); g.Dispose(); return bitmap; }