private Bitmap Flatten(Bitmap bmp, int fillint, int contint)
{
ColorFiltering colorFilter = new ColorFiltering();
colorFilter.Red = new IntRange(0, fillint);
colorFilter.Green = new IntRange(0, fillint);
colorFilter.Blue = new IntRange(0, fillint);
colorFilter.FillOutsideRange = false;
using (Bitmap filteredBmp = colorFilter.Apply(bmp))
{
AForge.Imaging.Filters.ContrastCorrection Contrast = new ContrastCorrection(contint);
AForge.Imaging.Filters.Invert invert = new Invert();
AForge.Imaging.Filters.ExtractChannel extract_channel = new ExtractChannel(RGB.B);
AForge.Imaging.Filters.Threshold thresh_hold = new Threshold(44);
Contrast.ApplyInPlace(filteredBmp);
Bitmap extractedBmp = extract_channel.Apply(filteredBmp);
thresh_hold.ApplyInPlace(extractedBmp);
invert.ApplyInPlace(extractedBmp);
return extractedBmp;
}
}
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 static void Face_Detection(Bitmap video)
{
ColorFiltering filter = new ColorFiltering();
// set color ranges to keep
filter.Red = new IntRange(0, 75);
filter.Green = new IntRange(0, 75);
filter.Blue = new IntRange(10, 255);
filter.ApplyInPlace(video);
}
/// <summary>
/// Limits the range of colors present on the given image.
/// </summary>
/// <param name="r">Range of R channel</param>
/// <param name="g">Range of G channel</param>
/// <param name="b">Range of B channel</param>
/// <param name="image">Image to filter</param>
public static void FilterColor(IntRange r, IntRange g, IntRange b, Bitmap image)
{
// create color filter
ColorFiltering colorFilter = new ColorFiltering();
// configure the filter to keep red object only
colorFilter.Red = r;
colorFilter.Green = g;
colorFilter.Blue = b;
// filter image
colorFilter.ApplyInPlace(image);
}
// rgb 필터
private Bitmap RGBfilter(Bitmap source)
{
// create filter
ColorFiltering filter = new ColorFiltering();
// set color ranges to keep
filter.Red = new IntRange(redMin, redMax);
filter.Green = new IntRange(greenMin, greenMax);
filter.Blue = new IntRange(blueMin, blueMax);
Bitmap processedImage = filter.Apply(source);
return processedImage;
}
public ActionResult Process(HttpPostedFileBase file)
{
var model = new List<TrainingDataItem>();
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);
// get information about detected objects
var shapeChecker = new SimpleShapeChecker();
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 base64 = (letter.ToBase64());
var sb = new StringBuilder();
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")
{
sb.Append("0");
bwBitmap.SetPixel(x - 40, y - 40, Color.Black);
}
else
{
sb.Append("1");
bwBitmap.SetPixel(x - 40, y - 40, Color.White);
}
}
sb.AppendLine();
}
model.Add(new TrainingDataItem
{
Base64Image = (bwBitmap.ToBase64()),
Letter = TrainingData.GetBestGuess(bwBitmap)
});
}
}
return View(model.ToArray());
}
// rgb 필터
public static Bitmap RGBfilter(Bitmap source)
{
///////////// ini 객체 생성 시작 /////////////////////////////////////////////////////
//현재 프로그램이 실행되고 있는정보 가져오기: 디버깅 모드라면 bin/debug/프로그램명.exe
FileInfo exefileinfo = new FileInfo(@"C:\Program Files\PLOCR\PLOCR.exe");
string pathini = exefileinfo.Directory.FullName.ToString(); //프로그램 실행되고 있는데 path 가져오기
string fileName = @"\PLOCRconfig.ini"; // 환경설정 파일명
string filePath = pathini + fileName; //ini 파일 경로
PLOCR.IniUtil ini = new PLOCR.IniUtil(filePath); // 만들어 놓았던 iniUtil 객체 생성(생성자 인자로 파일경로 정보 넘겨줌)
//////////// ini 객체 생성 끝 /////////////////////////////////////////////////////////
int redMin = int.Parse(ini.GetIniValue("색상필터값", "RedMin"));
int redMax = int.Parse(ini.GetIniValue("색상필터값", "RedMax"));
int greenMin = int.Parse(ini.GetIniValue("색상필터값", "GreenMin"));
int greenMax = int.Parse(ini.GetIniValue("색상필터값", "GreenMax"));
int blueMin = int.Parse(ini.GetIniValue("색상필터값", "BlueMin"));
int blueMax = int.Parse(ini.GetIniValue("색상필터값", "BlueMax"));
// create filter
ColorFiltering filter = new ColorFiltering();
// set color ranges to keep
filter.Red = new IntRange(redMin, redMax);
filter.Green = new IntRange(greenMin, greenMax);
filter.Blue = new IntRange(blueMin, blueMax);
Bitmap processedImage = filter.Apply(source);
return processedImage;
}
private void button4_Click(object sender, EventArgs e)
{
for (int i = 0; i < 305; i++)
{
Bitmap image = (Bitmap)System.Drawing.Image.FromFile("C:\\Users\\Halil\\Desktop\\frames\\image" + i + ".jpg");
Bitmap resim = new Bitmap(image);
Bitmap resimson = new Bitmap(image);
ColorFiltering filter = new ColorFiltering();
filter.Red = new IntRange(40, 87);
filter.Green = new IntRange(43, 85);
filter.Blue = new IntRange(63, 95);
filter.ApplyInPlace(resim);
nesnebul(resim, i, resimson);
}
MessageBox.Show("Yeni Resimler Oluşturuldu");
button3.Enabled = true;
}
private void InitFilters()
{
L_brownFilter = new ColorFiltering();
D_brownFilter = new ColorFiltering();
L_brownFilter.Red = new IntRange(125, 140);
L_brownFilter.Green = new IntRange(95, 110);
L_brownFilter.Blue = new IntRange(110, 130);
D_brownFilter.Red = new IntRange(55, 85);
D_brownFilter.Green = new IntRange(45, 75);
D_brownFilter.Blue = new IntRange(45, 75);
blobFilter = new BlobsFiltering();
blobFilter.CoupledSizeFiltering = true;
blobFilter.MinWidth = 70;
blobFilter.MinHeight = 70;
diffFilter = new Difference();
diffFilter.OverlayImage = back;
thresholdFilter = new Threshold(40);
erosionFilter = new Erosion();
edgeFilter = new Edges();
openFilter = new Opening();
pixelFilter = new Pixellate();
morphFilter = new Morph();
morphFilter.SourcePercent = 0.9;
towardsFilter = new MoveTowards();
towardsFilter.StepSize = 10;
blobCounter = new BlobCounter();
blobGrabber = new ExtractBiggestBlob();
}
public virtual void GetLiveImage()
{
if (_operInProgress)
{
// Log.Error("OperInProgress");
return;
}
if (DelayedStart)
{
//Log.Error("Start is delayed");
return;
}
if (FreezeImage)
return;
_operInProgress = true;
_totalframes++;
if ((DateTime.Now - _framestart).TotalSeconds > 0)
Fps = (int)(_totalframes / (DateTime.Now - _framestart).TotalSeconds);
try
{
LiveViewData = LiveViewManager.GetLiveViewImage(CameraDevice);
}
catch (Exception ex)
{
Log.Error("Error geting lv", ex);
_operInProgress = false;
return;
}
if (LiveViewData == null)
{
_operInProgress = false;
return;
}
if (!LiveViewData.IsLiveViewRunning && !IsFocusStackingRunning)
{
DelayedStart = true;
_restartTimerStartTime = DateTime.Now;
_restartTimer.Start();
_operInProgress = false;
return;
}
if (LiveViewData.ImageData == null)
{
// Log.Error("LV image data is null !");
_operInProgress = false;
return;
}
Recording = LiveViewData.MovieIsRecording;
try
{
if (LiveViewData != null && LiveViewData.ImageData != null)
{
MemoryStream stream = new MemoryStream(LiveViewData.ImageData,
LiveViewData.
ImageDataPosition,
LiveViewData.ImageData.
Length -
LiveViewData.
ImageDataPosition);
LevelAngle = (int)LiveViewData.LevelAngleRolling;
SoundL = LiveViewData.SoundL;
SoundR = LiveViewData.SoundR;
PeakSoundL = LiveViewData.PeakSoundL;
PeakSoundR = LiveViewData.PeakSoundR;
HaveSoundData = LiveViewData.HaveSoundData;
MovieTimeRemain = decimal.Round(LiveViewData.MovieTimeRemain, 2);
if (NoProcessing)
{
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.CacheOption = BitmapCacheOption.OnLoad;
bi.StreamSource = stream;
bi.EndInit();
bi.Freeze();
Bitmap = bi;
ServiceProvider.DeviceManager.LiveViewImage[CameraDevice] = stream.ToArray();
_operInProgress = false;
return;
}
using (var res = new Bitmap(stream))
{
Bitmap bmp = res;
if (PreviewTime > 0 && (DateTime.Now - _photoCapturedTime).TotalSeconds <= PreviewTime)
{
var bitmap = ServiceProvider.Settings.SelectedBitmap.DisplayImage.Clone();
//var dw = (double)bmp.Width / bitmap.PixelWidth;
//bitmap = bitmap.Resize((int)(bitmap.PixelWidth * dw), (int)(bitmap.PixelHeight * dw),
// WriteableBitmapExtensions.Interpolation.NearestNeighbor);
// flip image only if the prview not fliped
if (FlipImage && !ServiceProvider.Settings.FlipPreview)
bitmap = bitmap.Flip(WriteableBitmapExtensions.FlipMode.Vertical);
bitmap.Freeze();
ServiceProvider.DeviceManager.LiveViewImage[CameraDevice] = SaveJpeg(bitmap);
Bitmap = bitmap;
return;
}
if (DetectMotion)
{
ProcessMotionDetection(bmp);
}
if (_totalframes % DesiredFrameRate == 0 && ShowHistogram)
{
ImageStatisticsHSL hslStatistics =
new ImageStatisticsHSL(bmp);
LuminanceHistogramPoints =
ConvertToPointCollection(
hslStatistics.Luminance.Values);
ImageStatistics statistics = new ImageStatistics(bmp);
RedColorHistogramPoints = ConvertToPointCollection(
statistics.Red.Values);
GreenColorHistogramPoints = ConvertToPointCollection(
statistics.Green.Values);
BlueColorHistogramPoints = ConvertToPointCollection(
statistics.Blue.Values);
}
if (HighlightUnderExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(0, 5);
filtering.Red = new IntRange(0, 5);
filtering.Green = new IntRange(0, 5);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(Color.Blue);
filtering.ApplyInPlace(bmp);
}
if (HighlightOverExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(250, 255);
filtering.Red = new IntRange(250, 255);
filtering.Green = new IntRange(250, 255);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(Color.Red);
filtering.ApplyInPlace(bmp);
}
var preview = BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(bmp));
DrawFocusPoint(preview, true);
if (Brightness != 0)
{
BrightnessCorrection filter = new BrightnessCorrection(Brightness);
bmp = filter.Apply(bmp);
}
Bitmap newbmp = bmp;
if (EdgeDetection)
{
var filter = new FiltersSequence(
Grayscale.CommonAlgorithms.BT709,
new HomogenityEdgeDetector()
);
newbmp = filter.Apply(bmp);
}
WriteableBitmap writeableBitmap;
if (BlackAndWhite)
{
Grayscale filter = new Grayscale(0.299, 0.587, 0.114);
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(
filter.Apply(newbmp)));
}
else
{
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(newbmp));
}
DrawGrid(writeableBitmap);
switch (RotationIndex)
{
case 0:
Rotation = 0;
break;
case 1:
Rotation = 90;
break;
case 2:
Rotation = 180;
break;
case 3:
Rotation = 270;
break;
case 4:
Rotation = LiveViewData.Rotation;
break;
}
if (CameraDevice.LiveViewImageZoomRatio.Value == "All")
{
preview.Freeze();
Preview = preview;
if (ShowFocusRect)
DrawFocusPoint(writeableBitmap);
}
if (FlipImage)
{
writeableBitmap = writeableBitmap.Flip(WriteableBitmapExtensions.FlipMode.Vertical);
}
if (CropRatio > 0)
{
CropOffsetX = (int) ((writeableBitmap.PixelWidth/2.0)*CropRatio/100);
CropOffsetY = (int) ((writeableBitmap.PixelHeight/2.0)*CropRatio/100);
writeableBitmap = writeableBitmap.Crop(CropOffsetX, CropOffsetY,
writeableBitmap.PixelWidth - (2*CropOffsetX),
writeableBitmap.PixelHeight - (2*CropOffsetY));
}
writeableBitmap.Freeze();
Bitmap = writeableBitmap;
//if (_totalframes%DesiredWebFrameRate == 0)
ServiceProvider.DeviceManager.LiveViewImage[CameraDevice] = SaveJpeg(writeableBitmap);
}
stream.Close();
}
}
catch (Exception exception)
{
Log.Error(exception);
_operInProgress = false;
}
finally
{
_operInProgress = false;
}
_operInProgress = false;
}
void videoSource_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
var frame = eventArgs.Frame;
if (isTesting)
{
var r = new ColorFiltering(new IntRange(250, 255), new IntRange(250, 255), new IntRange(250, 255));
var r1 = r.Apply(frame);
ImageStatistics is0 = new ImageStatistics(r1);
int no = is0.PixelsCountWithoutBlack;
Console.WriteLine(no);
m_pictureBox.Image = r1;
return;
}
var cf1 = new ColorFiltering(new IntRange(250, 255), new IntRange(250, 255), new IntRange(250, 255));
var fi1 = cf1.Apply(frame);
ImageStatistics imageStatistics = new ImageStatistics(fi1);
int numOn = imageStatistics.PixelsCountWithoutBlack;
if (numOn > 10)
{
rawtext += "O";
}
else
{
rawtext += "-";
}
var ar = GetLetters(GuessMorseCode(rawtext)).ToArray();
if (ar.Length != 0)
{
decodedMessage += ar[0];
if (previousDecodedMessageLength != decodedMessage.Length)
{
foreach (var c in decodedMessage)
{
Console.Write(c);
}
Console.WriteLine();
previousDecodedMessageLength = decodedMessage.Length;
}
rawtext = string.Empty;
}
}
// Process image
private void ProcessImage( Bitmap bitmap )
{
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle( 0, 0, bitmap.Width, bitmap.Height ),
ImageLockMode.ReadWrite, bitmap.PixelFormat );
// step 1 - turn background to black
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 );
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
for ( int i = 0, n = blobs.Length; i < n; i++ )
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints( blobs[i] );
AForge.Point center;
float radius;
// is circle ?
if ( shapeChecker.IsCircle( edgePoints, out center, out radius ) )
{
g.DrawEllipse( yellowPen,
(float) ( center.X - radius ), (float) ( center.Y - radius ),
(float) ( radius * 2 ), (float) ( radius * 2 ) );
}
else
{
List<IntPoint> corners;
// is triangle or quadrilateral
if ( shapeChecker.IsConvexPolygon( edgePoints, out corners ) )
{
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType( corners );
Pen pen;
if ( subType == PolygonSubType.Unknown )
{
pen = ( corners.Count == 4 ) ? redPen : bluePen;
}
else
{
pen = ( corners.Count == 4 ) ? brownPen : greenPen;
}
g.DrawPolygon( pen, ToPointsArray( corners ) );
}
}
}
yellowPen.Dispose( );
redPen.Dispose( );
greenPen.Dispose( );
bluePen.Dispose( );
brownPen.Dispose( );
g.Dispose( );
// put new image to clipboard
Clipboard.SetDataObject( bitmap );
// and to picture box
pictureBox.Image = bitmap;
UpdatePictureBoxPosition( );
}
private void GetLiveImage()
{
if (_operInProgress)
return;
try
{
LiveViewData = SelectedCameraDevice.GetLiveViewImage();
}
catch (Exception ex)
{
Log.Error("Error geting lv", ex);
_operInProgress = false;
return;
}
if (LiveViewData == null)
{
_operInProgress = false;
return;
}
try
{
if (PreviewTime > 0 && (DateTime.Now - _photoCapturedTime).TotalSeconds <= PreviewTime)
{
Bitmap = ServiceProvider.Settings.SelectedBitmap.DisplayImage;
_operInProgress = false;
Console.WriteLine("Previeving");
return;
}
if (LiveViewData != null && LiveViewData.ImageData != null)
{
MemoryStream stream = new MemoryStream(LiveViewData.ImageData,
LiveViewData.
ImageDataPosition,
LiveViewData.ImageData.
Length -
LiveViewData.
ImageDataPosition);
LevelAngle = (int)LiveViewData.LevelAngleRolling;
AngleLevelPitching = LiveViewData.LevelAnglePitching;
AngleLevelYawing = LiveViewData.LevelAngleYawing;
using (var res = new Bitmap(stream))
{
Bitmap bmp = res;
if (_totalframes%DesiredFrameRate == 0 && ShowHistogram)
{
ImageStatisticsHSL hslStatistics =
new ImageStatisticsHSL(bmp);
LuminanceHistogramPoints =
ConvertToPointCollection(
hslStatistics.Luminance.Values);
ImageStatistics statistics = new ImageStatistics(bmp);
RedColorHistogramPoints = ConvertToPointCollection(
statistics.Red.Values);
GreenColorHistogramPoints = ConvertToPointCollection(
statistics.Green.Values);
BlueColorHistogramPoints = ConvertToPointCollection(
statistics.Blue.Values);
}
if (HighlightUnderExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(0, 5);
filtering.Red = new IntRange(0, 5);
filtering.Green = new IntRange(0, 5);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(System.Drawing.Color.Blue);
filtering.ApplyInPlace(bmp);
}
if (HighlightOverExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(250, 255);
filtering.Red = new IntRange(250, 255);
filtering.Green = new IntRange(250, 255);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(System.Drawing.Color.Red);
filtering.ApplyInPlace(bmp);
}
var preview = BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(bmp));
if (Brightness != 0)
{
BrightnessCorrection filter = new BrightnessCorrection(Brightness);
bmp = filter.Apply(bmp);
}
Bitmap newbmp = bmp;
if (EdgeDetection)
{
var filter = new FiltersSequence(
Grayscale.CommonAlgorithms.BT709,
new HomogenityEdgeDetector()
);
newbmp = filter.Apply(bmp);
}
WriteableBitmap writeableBitmap;
if (BlackAndWhite)
{
Grayscale filter = new Grayscale(0.299, 0.587, 0.114);
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(
filter.Apply(newbmp)));
}
else
{
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(newbmp));
}
DrawGrid(writeableBitmap);
DrawFocusPoint(writeableBitmap);
writeableBitmap.Freeze();
Bitmap = writeableBitmap;
_operInProgress = false;
}
return;
}
}
catch (Exception ex)
{
Log.Error("Error geting lv", ex);
_operInProgress = false;
return;
}
}
//returns corners of found rectangle
public List<IntPoint> getCorners(Bitmap toEdit)
{
Bitmap bitmap = new Bitmap(toEdit);
List<IntPoint> corners = new List<IntPoint>();
List<IntPoint> oneBlob = new List<IntPoint>();
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
//black background
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);
//locate figurres
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 8;
blobCounter.MinWidth = 8;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
//check object type
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(bitmap);
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
// check if trainge of rectangle
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get subtype (is rectangle?)
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (subType == PolygonSubType.Rectangle)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 3; k++)
{
IntPoint temp = new IntPoint();
if (j < 3)
{
if (corners[k].Y > corners[k + 1].Y)
{
temp = corners[k];
corners[k] = corners[k + 1];
corners[k + 1] = temp;
}
}
}
}
//sort list of corners
if (corners[0].X > corners[1].X)
{
IntPoint temp = new IntPoint();
temp = corners[0];
corners[0] = corners[1];
corners[1] = temp;
}
if (corners[3].X > corners[2].X)
{
IntPoint temp = new IntPoint();
temp = corners[2];
corners[2] = corners[3];
corners[3] = temp;
}
int blobHeigth = Math.Abs(corners[3].Y - corners[0].Y);
int blobWidth = Math.Abs(corners[1].X - corners[0].X);
if (blobHeigth < blobWidth)
{
// float ratio = blobWidth / blobHeigth;
// if(ratio > 1)
oneBlob = corners;
}
}
}
}
g.Dispose();
// put new image to clipboard
Clipboard.SetDataObject(bitmap);
// and to picture box
// pictureBox.Image = bitmap;
return oneBlob;
// UpdatePictureBoxPosition();
}
// Process image
public Bitmap ProcessImage(Bitmap toEdit)
{
Bitmap bitmap = new Bitmap(toEdit);
List<IntPoint> corners = new List<IntPoint>();
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
//black background
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);
//locating figures
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
//check type of figure
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(bitmap);
Pen redPen = new Pen(Color.Red, 2); // pen to colour egdes
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
// is triangle or rectangle
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get subtype (is rectangle?)
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
Pen pen;
/*
if (subType == PolygonSubType.Unknown)
{
pen = (corners.Count == 4) ? redPen : bluePen;
}
else
{
pen = (corners.Count == 4) ? brownPen : greenPen;
}
*/
if (subType == PolygonSubType.Rectangle)
{
int blobHeigth = Math.Abs(corners[3].Y - corners[0].Y);
int blobWidth = Math.Abs(corners[1].X - corners[0].X);
if (blobHeigth < blobWidth)
{
pen = redPen;
g.DrawPolygon(pen, ToPointsArray(corners));
}
}
}
}
redPen.Dispose();
g.Dispose();
Clipboard.SetDataObject(bitmap);
// and to picture box
// pictureBox.Image = bitmap;
return bitmap;
// UpdatePictureBoxPosition();
}
/// <summary>
/// Méthode qui analyse les images envoyées par le client
/// Repère les formes présentes, les découpe et les enregistre en ficiers distincts
/// </summary>
public void ProcessImage()
{
using (CamCapturer.CamCapturer cam = new CamCapturer.CamCapturer())
{
Picture = cam.GetCapture();
Copy = cam.GetCapture();
}
ShapeChecker = new SimpleShapeChecker();
ShapeAnalyser = new BlobCounter();
string date = DateTime.Now.Date.ToString("dMyyyy");
FolderName = string.Format("Kuhlschrank-{0}", date);
ShapeAnalyser.FilterBlobs = true;
ShapeAnalyser.MinHeight = 200;
ShapeAnalyser.MinWidth = 500;
Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), FolderName));
BitmapData bitData = Picture.LockBits(new Rectangle(0, 0, Picture.Width, Picture.Height), ImageLockMode.ReadWrite, Picture.PixelFormat);
ColorFiltering filter = new ColorFiltering();
filter.Red = new IntRange(0, 64);
filter.Green = new IntRange(0, 64);
filter.Blue = new IntRange(0, 64);
filter.FillOutsideRange = false;
filter.ApplyInPlace(bitData);
ShapeAnalyser.ProcessImage(bitData);
Blob[] blobs = ShapeAnalyser.GetObjectsInformation();
Picture.UnlockBits(bitData);
for (int i = 0; i < blobs.Length; i++)
{
List<IntPoint> edgePoints = ShapeAnalyser.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
ShapeChecker.IsConvexPolygon(edgePoints, out corners);
IntPoint pt0 = corners[0];
IntPoint pt1 = corners[1];
IntPoint pt2 = corners[2];
double width = Math.Sqrt(Math.Pow(pt1.X - pt0.X, 2) + Math.Pow(pt1.Y - pt0.Y, 2));
double height = Math.Sqrt(Math.Pow(pt2.X - pt1.X, 2) + Math.Pow(pt2.Y - pt1.Y, 2));
Rectangle crop = new Rectangle(corners[0].X, corners[1].Y, (int)width + 50, (int)height + 50);
Bitmap target = new Bitmap(crop.Width, crop.Height);
using (Graphics gr = Graphics.FromImage(target))
gr.DrawImage(Copy, new Rectangle(0, 0, target.Width, target.Height), crop, GraphicsUnit.Pixel);
target.Save(string.Format(@"{0}\{1}\crop{2}.jpg", Path.GetTempPath(), FolderName, i));
}
}
//Bitmap Source to Bitmap Convertor End
//Blob Counter Start
public Blob[] blobcounter(BitmapSource bsource)
{
System.Drawing.Bitmap b = BitmapFromSource(bsource);
BlobCounter BCounter = new BlobCounter();
ColorFiltering FilterObjects = new ColorFiltering();
BCounter.FilterBlobs = true;
BCounter.MinWidth = 50;
BCounter.MinHeight = 50;
BCounter.ProcessImage(b);
Blob[] detectedblobs = BCounter.GetObjectsInformation();
return detectedblobs;
}
/// <summary>
/// The ColorFilter is applied with the ColorRange from the background
/// </summary>
public void FilterImgBgSelect()
{
// CREATE NEW BITMAP IMAGE
this.bitmap = new Bitmap((Bitmap)pictureBox.Image);
// LOCK IMAGE
this.bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
// CREATE NEW FILTER
ColorFiltering colorFilter = new ColorFiltering();
// SET COLOR RANGE FOR BACKGROUND
colorFilter.Red = RangeRed;
colorFilter.Green = RangeGreen;
colorFilter.Blue = RangeBlue;
// DONT FILL OUTSIDE RANGE
colorFilter.FillOutsideRange = false;
// APPLY FILTER ON IMAGE
colorFilter.ApplyInPlace(bitmapData);
}
// Summary - Gets the exterior rectangles.
/***************
* It uses a different JPEG altogether due to bpp issue (only 24 or 32 is acceptable).
* Selects the rectangles on the basis of area (around 350 to 400).
* Sends the quadrilaterals (4 of them) with their 4 coordinates (each) to DecideCorners for trimming.
*/
public void PreProcess()
{
Bitmap bitmap = this.scanned_image;
List<List<IntPoint>> QuadCorners = new List<List<IntPoint>>(4);
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
// step 1 - turn background to black
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;
//MessageBox.Show(bitmapData.PixelFormat.ToString());
colorFilter.ApplyInPlace(bitmapData);
// step 2 - locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// step 3 - check objects' type and highlight
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
//int count = 0;
Pen redPen = new Pen(Color.Red, 2);
Graphics g = Graphics.FromImage(bitmap);
// Threshold area values for rectangles. It doesnt have a specific equation for the value based on threshold.
// Values have been tested and set accordingly.
int area_upper = 0, area_lower = 0;
if (Scanner_DPI.dpi_value == 200)
{
area_lower = 2000;
area_upper = 3000;
}
else if (Scanner_DPI.dpi_value == 300)
{
area_lower = 5000;
area_upper = 6000;
}
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
// is quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (subType == PolygonSubType.Rectangle && blobs[i].Area > area_lower && blobs[i].Area < area_upper)
{
//g.DrawPolygon(redPen, ToPointsArray(corners));
QuadCorners.Add(corners);
}
}
}
this.scanned_image = DecideCorners(QuadCorners);
}
/// <summary>
/// Gets the squares in the image
/// </summary>
/// <param name="cubeFace">Image to get the squares</param>
/// <param name="minWidth">Minimum square width</param>
/// <param name="minHeight">Minimum square height</param>
/// <returns>Returns the list with the squares.</returns>
public List<Rectangle> GetSquares(System.Drawing.Image cubeFace, int minWidth, int minHeight)
{
Squares = new List<Rectangle>();
Bitmap bitmap = new Bitmap(cubeFace);
// lock image
System.Drawing.Imaging.BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmap.PixelFormat);
// step 1 - turn background to black
ColorFiltering colorFilter = new ColorFiltering();
colorFilter.Red = new AForge.IntRange(0, 64);
colorFilter.Green = new AForge.IntRange(0, 64);
colorFilter.Blue = new AForge.IntRange(0, 64);
colorFilter.FillOutsideRange = false;
colorFilter.ApplyInPlace(bitmapData);
// step 2 - locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = minHeight;
blobCounter.MinWidth = minWidth;
blobCounter.ProcessImage(bitmapData);
AForge.Imaging.Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// step 3 - check objects' type and highlight
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners) && corners.Count == 4)
{
Squares.Add(blobs[i].Rectangle);
}
}
return Squares;
}
public void ProcessLiveView(Bitmap bmp)
{
if (PreviewTime > 0 && (DateTime.Now - _photoCapturedTime).TotalSeconds <= PreviewTime)
{
var bitmap = ServiceProvider.Settings.SelectedBitmap.DisplayImage.Clone();
// flip image only if the prview not fliped
if (FlipImage && !ServiceProvider.Settings.FlipPreview)
bitmap = bitmap.Flip(WriteableBitmapExtensions.FlipMode.Vertical);
bitmap.Freeze();
ServiceProvider.DeviceManager.LiveViewImage[CameraDevice] = SaveJpeg(bitmap);
Bitmap = bitmap;
return;
}
if (DetectMotion)
{
ProcessMotionDetection(bmp);
}
if (_totalframes%DesiredFrameRate == 0 && ShowHistogram)
{
ImageStatisticsHSL hslStatistics =
new ImageStatisticsHSL(bmp);
LuminanceHistogramPoints =
ConvertToPointCollection(
hslStatistics.Luminance.Values);
ImageStatistics statistics = new ImageStatistics(bmp);
RedColorHistogramPoints = ConvertToPointCollection(
statistics.Red.Values);
GreenColorHistogramPoints = ConvertToPointCollection(
statistics.Green.Values);
BlueColorHistogramPoints = ConvertToPointCollection(
statistics.Blue.Values);
}
if (HighlightUnderExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(0, 5);
filtering.Red = new IntRange(0, 5);
filtering.Green = new IntRange(0, 5);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(Color.Blue);
filtering.ApplyInPlace(bmp);
}
if (HighlightOverExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(250, 255);
filtering.Red = new IntRange(250, 255);
filtering.Green = new IntRange(250, 255);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(Color.Red);
filtering.ApplyInPlace(bmp);
}
var preview = BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(bmp));
DrawFocusPoint(preview, true);
if (Brightness != 0)
{
BrightnessCorrection filter = new BrightnessCorrection(Brightness);
bmp = filter.Apply(bmp);
}
Bitmap newbmp = bmp;
if (EdgeDetection)
{
var filter = new FiltersSequence(
Grayscale.CommonAlgorithms.BT709,
new HomogenityEdgeDetector()
);
newbmp = filter.Apply(bmp);
}
WriteableBitmap writeableBitmap;
if (BlackAndWhite)
{
Grayscale filter = new Grayscale(0.299, 0.587, 0.114);
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(
filter.Apply(newbmp)));
}
else
{
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(newbmp));
}
DrawGrid(writeableBitmap);
switch (RotationIndex)
{
case 0:
Rotation = 0;
break;
case 1:
Rotation = 90;
break;
case 2:
Rotation = 180;
break;
case 3:
Rotation = 270;
break;
case 4:
Rotation = LiveViewData.Rotation;
break;
}
if (CameraDevice.LiveViewImageZoomRatio.Value == "All")
{
preview.Freeze();
Preview = preview;
if (ShowFocusRect)
DrawFocusPoint(writeableBitmap);
}
if (FlipImage)
{
writeableBitmap = writeableBitmap.Flip(WriteableBitmapExtensions.FlipMode.Vertical);
}
if (CropRatio > 0)
{
CropOffsetX = (int) ((writeableBitmap.PixelWidth/2.0)*CropRatio/100);
CropOffsetY = (int) ((writeableBitmap.PixelHeight/2.0)*CropRatio/100);
writeableBitmap = writeableBitmap.Crop(CropOffsetX, CropOffsetY,
writeableBitmap.PixelWidth - (2*CropOffsetX),
writeableBitmap.PixelHeight - (2*CropOffsetY));
}
writeableBitmap.Freeze();
Bitmap = writeableBitmap;
//if (_totalframes%DesiredWebFrameRate == 0)
ServiceProvider.DeviceManager.LiveViewImage[CameraDevice] = SaveJpeg(writeableBitmap);
}
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 bool findBlobs()
{
if (currentImage != null)
{
try
{
Bitmap image = new Bitmap(this.currentImage);
// lock image
BitmapData bmData = image.LockBits(
new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadWrite, image.PixelFormat);
// turn background to black
ColorFiltering cFilter = new ColorFiltering();
cFilter.Red = new IntRange(0, 64);
cFilter.Green = new IntRange(0, 64);
cFilter.Blue = new IntRange(0, 64);
cFilter.FillOutsideRange = false;
cFilter.ApplyInPlace(bmData);
// locate objects
BlobCounter bCounter = new BlobCounter();
bCounter.FilterBlobs = true;
bCounter.MinHeight = 20;
bCounter.MinWidth = 20;
bCounter.ProcessImage(bmData);
//unlock the image before doing anything with it.
image.UnlockBits(bmData);
Blob[] baBlobs = bCounter.GetObjects(image, true);
// blobs is an array of the object gathered
foreach (Blob b in baBlobs)
{
// some test code to shwo the new images
using (Form form = new Form())
{
// this line is used to convert the blob to a new bitmap img
Bitmap img = b.Image.ToManagedImage();
form.StartPosition = FormStartPosition.CenterScreen;
form.Size = img.Size;
PictureBox pb = new PictureBox();
pb.Dock = DockStyle.Fill;
pb.Image = img;
form.Controls.Add(pb);
form.ShowDialog();
}
}
return true;
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
// // locate objects
// BlobCounter bCounter = new BlobCounter();
// bCounter.FilterBlobs = true;
// bCounter.MinHeight = 30;
// bCounter.MinWidth = 30;
// bCounter.ProcessImage(bmData);
// Blob[] baBlobs = bCounter.GetObjectsInformation();
// image.UnlockBits(bmData);
// // coloring objects
// SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
// Graphics g = Graphics.FromImage(image);
// 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
// for (int i = 0, n = baBlobs.Length; i < n; i++)
// {
// List<IntPoint> edgePoints = bCounter.GetBlobsEdgePoints(baBlobs[i]);
// AForge.Point center;
// float radius;
// // is circle ?
// if (shapeChecker.IsCircle(edgePoints, out center, out radius))
// {
// g.DrawEllipse(yellowPen,
// (float)(center.X - radius), (float)(center.Y - radius),
// (float)(radius * 2), (float)(radius * 2));
// }
// else
// {
// List<IntPoint> corners;
// // is triangle or quadrilateral
// if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
// {
// PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
// Pen pen;
// if (subType == PolygonSubType.Unknown)
// {
// pen = (corners.Count == 4) ? redPen : bluePen;
// }
// else
// {
// pen = (corners.Count == 4) ? brownPen : greenPen;
// }
// g.DrawPolygon(pen, ToPointsArray(corners));
// }
// }
// }
// yellowPen.Dispose();
// redPen.Dispose();
// greenPen.Dispose();
// bluePen.Dispose();
// brownPen.Dispose();
// g.Dispose();
// this.currentImage = image;
// return true;
// }
// catch (Exception e)
// {
// }
//}
return false;
}
private Bitmap ApplyRGBFilter(Bitmap sourceImage)
{
ColorFiltering filter = new ColorFiltering();
filter.Red = new AForge.IntRange(50, red);
filter.Green = new AForge.IntRange(50, green);
filter.Blue = new AForge.IntRange(50, blue);
Bitmap processedImage = filter.Apply(sourceImage);
filter.ApplyInPlace(processedImage);
return processedImage;
}
static void videoSource_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
var frame = eventArgs.Frame;
if (m_isTesting)
{
var r = new ColorFiltering(new IntRange(250, 255), new IntRange(250, 255), new IntRange(250, 255));
var r1 = r.Apply(frame);
ImageStatistics is0 = new ImageStatistics(r1);
int no = is0.PixelsCountWithoutBlack;
Console.WriteLine(no);
return;
}
var cf1 = new ColorFiltering(new IntRange(250, 255), new IntRange(250, 255), new IntRange(250, 255));
var fi1 = cf1.Apply(frame);
ImageStatistics imageStatistics = new ImageStatistics(fi1);
int numOn = imageStatistics.PixelsCountWithoutBlack;
if (numOn > 15)
{
m_rawtext += "O";
}
else
{
m_rawtext += "-";
}
Console.Clear();
Console.SetCursorPosition(0, 1);
Console.Write(m_rawtext);
var ar = GetLetters(GuessMorseCode(m_rawtext)).ToArray();
if (ar.Length != 0)
{
foreach(var v in ar)
m_decodedMessage += v;
m_rawtext = string.Empty;
}
string message = "'";
foreach (var c in m_decodedMessage)
{
message += c;
}
message += "'";
Console.SetCursorPosition(0, 4);
Console.Write(message);
}
/// <summary>
/// Este metodo toma la imagen en pantalla, realiza una copia, y detecta las areas circulares
/// Las areas circulares se dibujan en la imagen en pantalla
/// </summary>
/// <returns>Vector Rectangle[] con las areas encontradas</returns>
public Rectangle[] DetectarBordes()
{
// se reestablece la imagen
ResetPictBox();
// se realiza una copia de la imagen
Bitmap slide = FormatToAForge(new Bitmap(pictElemento.Image));
slide.Save("slide.jpg");
// lock image
BitmapData bitmapData = slide.LockBits(
new Rectangle(0, 0, slide.Width, slide.Height),
ImageLockMode.ReadWrite, slide.PixelFormat);
// se realiza el primer barrido, dividiendo la imagen usando el primer treshold
ColorFiltering colorFilter = new ColorFiltering();
int valorThreshold = Convert.ToInt32(track1.Value);
colorFilter.Red = new IntRange(0, valorThreshold);
colorFilter.Green = new IntRange(0, valorThreshold);
colorFilter.Blue = new IntRange(0, valorThreshold);
colorFilter.FillOutsideRange = false;
colorFilter.ApplyInPlace(bitmapData);
// se localizan los elementos circulares
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData);
Blob[] blobsTemp = blobCounter.GetObjectsInformation();
slide.UnlockBits(bitmapData);
// se eliminan los blobs no cuadrados, aquellos cuya relacion Abs(1-width/heigh) es mayor a 0.2, ademas de reordenar los blobs de menor a mayor area
List<Blob> blobs = new List<Blob>();
// se hace una copia
for (int i = 0; i < blobsTemp.Length; i++) blobs.Add(blobsTemp[i]);
// se eliminan los rectangulares
for (int i = 0; i < blobs.Count; i++)
{
if (Math.Abs(1 - (blobs[i].Rectangle.Height / blobs[i].Rectangle.Width)) > 0.2) blobs.RemoveAt(i);
}
// se ordenan los blobs de mayor area a menor area
blobs.Sort(delegate(Blob x, Blob y)
{
return (y.Rectangle.Height * y.Rectangle.Width).CompareTo(x.Rectangle.Height * x.Rectangle.Width);
});
// solo se toman los 4 blobs mas grandes
while (blobs.Count > 4) blobs.RemoveAt(blobs.Count - 1);
// se prepara el vector de salida
Rectangle[] areas = new Rectangle[blobs.Count];
for (int i = 0; i < blobs.Count; i++) areas[i] = blobs[i].Rectangle;
/*///
Bitmap imagen = new Bitmap(pictElemento.Image);
Graphics g = Graphics.FromImage(imagen);
for (int i = 0; i < blobs.Count; i++) g.DrawEllipse(pen1, blobs[i].Rectangle);
pictElemento.Image = imagen;
///*/
return areas;
/*
// se extrae el elemento mas grande
try
{
Bitmap imagen = new Bitmap(pictElemento.Image);
Bitmap subslide = imagen.Clone(blobs[0].Rectangle, imagen.PixelFormat);
subslide = FormatToAForge(subslide);
subslide.Save("subslide.jpg");
// sobre la seccion del elemento mas grade se realiza el mismo proceso
// pero usando el segundo valor de threshold
// primero se hace una copia
Bitmap subslide2 = FormatToAForge(subslide);
// lock image
BitmapData bitmapData2 = subslide2.LockBits(
new Rectangle(0, 0, subslide2.Width, subslide2.Height),
ImageLockMode.ReadWrite, subslide2.PixelFormat);
// se realiza el primer barrido, dividiendo la imagen usando el primer treshold
colorFilter = new ColorFiltering();
valorThreshold = Convert.ToInt32(track2.Value);
colorFilter.Red = new IntRange(0, valorThreshold);
colorFilter.Green = new IntRange(0, valorThreshold);
colorFilter.Blue = new IntRange(0, valorThreshold);
colorFilter.FillOutsideRange = false;
colorFilter.ApplyInPlace(bitmapData2);
// se localizan los elementos circulares
BlobCounter blobCounter2 = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData2);
Blob[] blobs2 = blobCounter.GetObjectsInformation();
subslide2.UnlockBits(bitmapData2);
// se enmarcan los elementos encontrados
try
{
// ahora se dibuja en la imagen principal las zonas
// primero se obtiene la posicion del ultimo recuadro pero en funcion de la imagen principal
Rectangle[] areas = new Rectangle[4];
areas[0] = new Rectangle(blobs[0].Rectangle.X + blobs2[1].Rectangle.X,
blobs[0].Rectangle.Y + blobs2[1].Rectangle.Y,
blobs2[1].Rectangle.Width,
blobs2[1].Rectangle.Height);
// se copian el resto de los elementos
areas[1] = blobs[1].Rectangle;
areas[2] = blobs[2].Rectangle;
areas[3] = blobs[3].Rectangle;
// se incrementa un poco el encuadre
for (int i = 0; i < areas.Length; i++)
{
areas[i].X = areas[i].X - 2;
areas[i].Y = areas[i].Y - 2;
areas[i].Width = areas[i].Width + 4;
areas[i].Height = areas[i].Height + 4;
}
///
Graphics g = Graphics.FromImage(imagen);
for (int i = 0; i < areas.Length; i++) g.DrawRectangle(pen1, areas[i]);
pictElemento.Image = imagen;
///
return areas;
}
catch
{
return null;
}
}
catch { return null; }
*/
}
public virtual void GetLiveImage()
{
if (_operInProgress)
return;
if (DelayedStart)
return;
_operInProgress = true;
_totalframes++;
if ((DateTime.Now - _framestart).TotalSeconds > 0)
Fps = (int) (_totalframes/(DateTime.Now - _framestart).TotalSeconds);
try
{
LiveViewData = LiveViewManager.GetLiveViewImage(CameraDevice);
}
catch (Exception)
{
_retries++;
_operInProgress = false;
return;
}
if (LiveViewData == null )
{
_retries++;
_operInProgress = false;
return;
}
if (!LiveViewData.IsLiveViewRunning)
{
DelayedStart = true;
_restartTimerStartTime = DateTime.Now;
_restartTimer. Start();
_operInProgress = false;
return;
}
if (LiveViewData.ImageData == null)
{
_retries++;
_operInProgress = false;
return;
}
Recording = LiveViewData.MovieIsRecording;
try
{
WriteableBitmap preview;
if (LiveViewData != null && LiveViewData.ImageData != null)
{
MemoryStream stream = new MemoryStream(LiveViewData.ImageData,
LiveViewData.
ImageDataPosition,
LiveViewData.ImageData.
Length -
LiveViewData.
ImageDataPosition);
using (var res = new Bitmap(stream))
{
Bitmap bmp = res;
if (DetectMotion)
{
ProcessMotionDetection(bmp);
}
if (_totalframes % DesiredFrameRate == 0 && ShowHistogram)
{
ImageStatisticsHSL hslStatistics =
new ImageStatisticsHSL(bmp);
LuminanceHistogramPoints =
ConvertToPointCollection(
hslStatistics.Luminance.Values);
ImageStatistics statistics = new ImageStatistics(bmp);
RedColorHistogramPoints = ConvertToPointCollection(
statistics.Red.Values);
GreenColorHistogramPoints = ConvertToPointCollection(
statistics.Green.Values);
BlueColorHistogramPoints = ConvertToPointCollection(
statistics.Blue.Values);
}
if (HighlightUnderExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(0, 5);
filtering.Red = new IntRange(0, 5);
filtering.Green = new IntRange(0, 5);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(System.Drawing.Color.Blue);
filtering.ApplyInPlace(bmp);
}
if (HighlightOverExp)
{
ColorFiltering filtering = new ColorFiltering();
filtering.Blue = new IntRange(250, 255);
filtering.Red = new IntRange(250, 255);
filtering.Green = new IntRange(250, 255);
filtering.FillOutsideRange = false;
filtering.FillColor = new RGB(System.Drawing.Color.Red);
filtering.ApplyInPlace(bmp);
}
if (Brightness != 0)
{
BrightnessCorrection filter = new BrightnessCorrection(Brightness);
bmp = filter.Apply(bmp);
}
preview =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(bmp));
DrawFocusPoint(preview);
Bitmap newbmp = bmp;
if (EdgeDetection)
{
var filter = new FiltersSequence(
Grayscale.CommonAlgorithms.BT709,
new HomogenityEdgeDetector()
);
newbmp = filter.Apply(bmp);
}
WriteableBitmap writeableBitmap;
if (BlackAndWhite)
{
Grayscale filter = new Grayscale(0.299, 0.587, 0.114);
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(
filter.Apply(newbmp)));
}
else
{
writeableBitmap =
BitmapFactory.ConvertToPbgra32Format(
BitmapSourceConvert.ToBitmapSource(newbmp));
}
DrawGrid(writeableBitmap);
if (RotationIndex != 0)
{
switch (RotationIndex)
{
case 1:
writeableBitmap = writeableBitmap.Rotate(90);
break;
case 2:
writeableBitmap = writeableBitmap.Rotate(180);
break;
case 3:
writeableBitmap = writeableBitmap.Rotate(270);
break;
case 4:
if (LiveViewData.Rotation != 0)
writeableBitmap =
writeableBitmap.RotateFree(
LiveViewData.Rotation, false);
break;
}
}
if (CameraDevice.LiveViewImageZoomRatio.Value == "All")
{
preview.Freeze();
Preview = preview;
if (ShowFocusRect)
DrawFocusPoint(writeableBitmap);
}
writeableBitmap.Freeze();
Bitmap = writeableBitmap;
if (_totalframes%DesiredWebFrameRate == 0)
ServiceProvider.DeviceManager.LiveViewImage[CameraDevice] = SaveJpeg(writeableBitmap);
}
stream.Close();
}
}
catch (Exception exception)
{
Log.Error(exception);
_retries++;
_operInProgress = false;
}
_retries = 0;
_operInProgress = false;
}
public bool markKnownForms()
{
if (currentImage != null)
{
try
{
Bitmap image = new Bitmap(this.currentImage);
// lock image
BitmapData bmData = image.LockBits(
new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadWrite, image.PixelFormat);
// turn background to black
ColorFiltering cFilter = new ColorFiltering();
cFilter.Red = new IntRange(0, 64);
cFilter.Green = new IntRange(0, 64);
cFilter.Blue = new IntRange(0, 64);
cFilter.FillOutsideRange = false;
cFilter.ApplyInPlace(bmData);
// locate objects
BlobCounter bCounter = new BlobCounter();
bCounter.FilterBlobs = true;
bCounter.MinHeight = 5;
bCounter.MinWidth = 5;
bCounter.ProcessImage(bmData);
numberOfShellsDetected = bCounter.ObjectsCount;
Blob[] baBlobs = bCounter.GetObjectsInformation();
image.UnlockBits(bmData);
// coloring objects
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(image);
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
for (int i = 0, n = baBlobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = bCounter.GetBlobsEdgePoints(baBlobs[i]);
foreach (IntPoint point in edgePoints)
g.DrawEllipse(redPen, point.X, point.Y, 2, 2);
/*AForge.Point center;
float radius;
// is circle ?
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
numberOfShellsDetected++;
g.DrawEllipse(redPen,
(float)(center.X - radius), (float)(center.Y - radius),
(float)(radius * 2), (float)(radius * 2));
}*/
/*else
{
List<IntPoint> corners;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
Pen pen;
if (subType == PolygonSubType.Unknown)
{
pen = (corners.Count == 4) ? redPen : bluePen;
}
else
{
pen = (corners.Count == 4) ? brownPen : greenPen;
}
g.DrawPolygon(pen, ToPointsArray(corners));
}
}*/
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
brownPen.Dispose();
g.Dispose();
this.currentImage = image;
return true;
}
catch (Exception e)
{
}
}
return false;
}
private void traitementimage(ref Bitmap image)
{
ColorFiltering filter = new ColorFiltering();
filter.Red = new IntRange(254, 255);
filter.Green = new IntRange(0, 240);
filter.Blue = new IntRange(0, 240);
Bitmap tmp = filter.Apply(image);
IFilter grayscale = new GrayscaleBT709();
tmp = grayscale.Apply(tmp);
BitmapData bitmapData = tmp.LockBits(new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(bitmapData);
blobCounter.ObjectsOrder = ObjectsOrder.Size;
Rectangle[] rects = blobCounter.GetObjectsRectangles();
tmp.UnlockBits(bitmapData);
tmp.Dispose();
if (rects.Length != 0)
{
backpoint = Centre(rects[0]);
lignes(ref image, backpoint);
}
}
private void AnaliseMap(Bitmap mapImage)
{
mapData.Clear();
ColorFiltering filter = new ColorFiltering();
Trace.WriteLine("Analysing color map " + mapLocation + "...");
foreach (String action in colorMap.Actions)
{
Color actionColor = colorMap.GetColorFor(action);
filter.Red = new IntRange(actionColor.R, actionColor.R);
filter.Green = new IntRange(actionColor.G, actionColor.G);
filter.Blue = new IntRange(actionColor.B, actionColor.B);
using (Bitmap colorFilteredMapImage = filter.Apply(mapImage))
{
// Once we have isolated the action color on the map image
// we need to find the biggest rectangle left in the map (as there could be noise)
BlobCounter bc = new BlobCounter();
bc.ProcessImage(colorFilteredMapImage);
Rectangle[] rects = bc.GetObjectsRectangles();
if (rects.Count<Rectangle>() == 0) Trace.WriteLine("Warning: No rectangles were found for " + actionColor.ToString());
Rectangle biggestRect = Rectangle.Empty;
foreach (Rectangle rect in rects)
{
// Compare areas
if (rect.Width * rect.Height > biggestRect.Width * biggestRect.Height)
{
biggestRect = rect;
}
}
// Did we find a rectangle?
if (!biggestRect.Equals(Rectangle.Empty) && (biggestRect.Width * biggestRect.Height > MIN_AREA_THRESHOLD))
{
Trace.WriteLine("Found rectangle for " + action + ": " + biggestRect.ToString());
mapData[action] = biggestRect;
}
}
}
}
