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;
}
