/// <summary> /// Implements an 8-connected region growing algorithm based on histogram similarity (using back projection). /// Starts with the starting pixel and checks in the back projection all the four pixel around it. /// If the pixels pass some threshold, they are selected and the region is grown to contain them as well. /// </summary> public static void Fill(Point startPoint, CVImage outputImage, RegionGrowingCriteria criteria, object criteriaCookie, LabelingFunc labelFunc, object labelingCookie) { // first, include the starting pixel in the region. labelFunc(outputImage, startPoint, labelingCookie); // go over all the connection points. foreach (Point connection in connections) { Point connectionPoint = new Point( startPoint.X + (int)connection.X, startPoint.Y + (int)connection.Y); if (!outputImage.Contains(connectionPoint)) continue; // consider this point only if it's not already in the region. if (outputImage[connectionPoint].GrayLevel != 0) continue; // only if growing criteria is met, recurse away. if (criteria(startPoint, connectionPoint, criteriaCookie)) { // recurse into the new connection point. Fill(connectionPoint, outputImage, criteria, criteriaCookie, labelFunc, labelingCookie); } } }
/// <summary> /// Implements an 8-connected region growing algorithm based on histogram similarity (using back projection). /// Starts with the starting pixel and checks in the back projection all the four pixel around it. /// If the pixels pass some threshold, they are selected and the region is grown to contain them as well. /// </summary> public static void Fill(Point startPoint, CVImage outputImage, RegionGrowingCriteria criteria, object criteriaCookie, LabelingFunc labelFunc, object labelingCookie) { // first, include the starting pixel in the region. labelFunc(outputImage, startPoint, labelingCookie); // go over all the connection points. foreach (Point connection in connections) { Point connectionPoint = new Point( startPoint.X + (int)connection.X, startPoint.Y + (int)connection.Y); if (!outputImage.Contains(connectionPoint)) { continue; } // consider this point only if it's not already in the region. if (outputImage[connectionPoint].GrayLevel != 0) { continue; } // only if growing criteria is met, recurse away. if (criteria(startPoint, connectionPoint, criteriaCookie)) { // recurse into the new connection point. Fill(connectionPoint, outputImage, criteria, criteriaCookie, labelFunc, labelingCookie); } } }
/// <summary> /// Can be used in the call to Fill() as the default labeling function. /// This function merely colors the pixel in the color specified under labelCookie /// which should be a Color object. /// </summary> public static void DefaultLabeling(CVImage outputImage, Point pt, object labelCookie) { if (!outputImage.Contains(pt)) return; if (outputImage[pt].GrayLevel != 0) return; Color c = (Color)labelCookie; outputImage[pt] = new CVRgbPixel(c); }
public void ShowHistogram(CVImage image, CVImage mask) { if (image == null) { return; } // split image into channels (b,g,r) CVImage[] planes = image.Split(); // we will create a 1D histogram for every channel. each histogram will have // 'numberOfBins' bins for its single dimension (ranged from 0 to 255). int[] bins = { BinsPerChannel }; CVPair[] ranges = { new CVPair(0, 255) }; // calculate histogram for red, green and blue channels (seperately). CVHistogram histoRed = planes[0].CalcHistogram(bins, ranges, mask); CVHistogram histoBlue = planes[1].CalcHistogram(bins, ranges, mask); CVHistogram histoGreen = planes[2].CalcHistogram(bins, ranges, mask); // dispose of plane images. foreach (CVImage img in planes) { img.Release(); } // draw the three histograms. DrawHistogram(bluePanel, histoBlue, 1); DrawHistogram(greenPanel, histoGreen, 2); DrawHistogram(redPanel, histoRed, 0); histoBlue.Release(); histoGreen.Release(); histoRed.Release(); }
private void Track() { if (image == null) { return; } // calculate the back projection of the current image on top of the initial histogram. using (CVImage bp = image.CalcBackProject(this.initialHistogram)) { // show the back projection. backProjectImage.Image = bp.ToBitmap(); // calculate mean shift with user parameters and region of interest. CVConnectedComp conn = bp.MeanShift(originalImage.SelectionRect, Iterations); // update region of interest according to mean shift result. originalImage.SelectionRect = conn.Rect; } // rotate update counter only if rate != 0. if (UpdateHistogramRate != 0) { updateHistoCounter = (updateHistoCounter + 1) % UpdateHistogramRate; // update histogram is counter reached 0. if (updateHistoCounter == 0) { UpdateHistogram(); } } // refresh images. RefreshImages(); }
public void ShowHistogram(CVImage image, CVImage mask) { if (image == null) return; // split image into channels (b,g,r) CVImage[] planes = image.Split(); // we will create a 1D histogram for every channel. each histogram will have // 'numberOfBins' bins for its single dimension (ranged from 0 to 255). int[] bins = { BinsPerChannel }; CVPair[] ranges = { new CVPair(0, 255) }; // calculate histogram for red, green and blue channels (seperately). CVHistogram histoRed = planes[0].CalcHistogram(bins, ranges, mask); CVHistogram histoBlue = planes[1].CalcHistogram(bins, ranges, mask); CVHistogram histoGreen = planes[2].CalcHistogram(bins, ranges, mask); // dispose of plane images. foreach (CVImage img in planes) img.Release(); // draw the three histograms. DrawHistogram(bluePanel, histoBlue, 1); DrawHistogram(greenPanel, histoGreen, 2); DrawHistogram(redPanel, histoRed, 0); histoBlue.Release(); histoGreen.Release(); histoRed.Release(); }
/// <summary> /// Can be used to implement flood fill. /// </summary> public static bool FloodFillCondition(CVImage frame, Point startPt, Point candidatePt, int tolerange) { if (!frame.Contains(candidatePt) || !frame.Contains(startPt)) { return(false); } return(Math.Abs(frame[startPt].GrayLevel - frame[candidatePt].GrayLevel) <= tolerange); }
/// <summary> /// Label 8-connected points from each point with color. /// </summary> public static void EightConnectedLabeling(CVImage outputImage, Point pt, object colorCookie) { foreach (Point conn in connections) { Point connectPt = new Point(pt.X + conn.X, pt.Y + conn.Y); DefaultLabeling(outputImage, connectPt, colorCookie); } }
private static void TestDrawContours() { CVImage image = new CVImage(100, 100, CVDepth.Depth8U, 1); image.DrawRectangle(new System.Drawing.Rectangle(10, 10, 20, 30), System.Drawing.Color.Red, 3); new BitmapViewer(image.ToBitmap()).ShowDialog(); CVImage res = image.DrawContours(); new BitmapViewer(res.ToBitmap()).ShowDialog(); }
private void ProcessBackgroundSubtraction() { CVImage frame = videoPlayer.LastFrame; // access last frame from video player. for (int row = 0; row < frame.Height; ++row) { for (int col = 0; col < frame.Width; ++col) { CVRgbPixel pixel = frame[row, col]; // get black and white value for this pixel. int bwValue = pixel.BwValue; // accumulate the new value to the moving average. double val = (double)bwValue / 255.0; if (bgAccum[row, col] == -1) { bgAccum[row, col] = val; } else { bgAccum[row, col] = alpha * val + (1 - alpha) * bgAccum[row, col]; } // calculate the diff between the frame and the average up until now. double delta = val - bgAccum[row, col]; byte currentBgValue = bgFrame[row, col].BwValue; if (currentBgValue > 0) { currentBgValue -= STEP_SIZE; } // if delta is smaller than the threshold, eliminate the background. if (delta < threshold) { // set the color of the background frame to black. //bgFrame[row, col] = new CVRgbPixel(0, 0, 0); } else { currentBgValue = 255; } bgFrame[row, col] = new CVRgbPixel(currentBgValue, currentBgValue, currentBgValue); } } // display the updated frame on the window. bs.Image = bgFrame.ToBitmap(); }
private void videoTimer_Tick(object sender, EventArgs e) { image = cap.QueryFrame(); if (image == null) { cap.Restart(); } Track(); }
private void openToolStripMenuItem_Click(object sender, EventArgs e) { OpenFileDialog openFile = new OpenFileDialog(); openFile.Title = "Select Image File"; if (openFile.ShowDialog() != DialogResult.OK) { return; } image = new CVImage(openFile.FileName); Track(); }
private bool MyRGCriteria(Point startPt, Point candidatePt, object frameCookie) { CVImage frame = frameCookie as CVImage; int tolerance; if (!int.TryParse(grayscaleTolerance.Text, out tolerance)) { tolerance = 1; } return(Math.Abs(frame[startPt].GrayLevel - frame[candidatePt].GrayLevel) <= tolerance); }
/// <summary> /// Creates a new image that will be used as a mask for the histogram calculation. /// All forground points will be colored blue and all background points will be colored red. /// </summary> public static CVImage PrepareMask(CVImage image, Point[] forgroundPoints, Point[] backgroundPoints, bool includeNeautral, int floodFillThreshold) { CVImage outputImage = image.Clone(); outputImage.Zero(); FloodFillParams ffp = new FloodFillParams(); ffp.Frame = image; ffp.Threshold = floodFillThreshold; // fill all forground points in FG_COLOR foreach (Point pt in forgroundPoints) { RegionGrowing.Fill(pt, outputImage, new RegionGrowingCriteria(FloodFill), ffp, new LabelingFunc(RegionGrowing.DefaultLabeling), FG_COLOR); } // fill all background points in BG_COLOR foreach (Point pt in backgroundPoints) { RegionGrowing.Fill(pt, outputImage, new RegionGrowingCriteria(FloodFill), ffp, new LabelingFunc(RegionGrowing.DefaultLabeling), TEMP_BG_COLOR); } // now colorize to actual colors. for (int row = 0; row < outputImage.Height; ++row) { for (int col = 0; col < outputImage.Width; ++col) { int argb = outputImage[row, col].ToColor().ToArgb(); if (includeNeautral) { if (argb == Color.Black.ToArgb()) { outputImage[row, col] = new CVRgbPixel(NEAUTRAL_COLOR); } } if (argb == TEMP_BG_COLOR.ToArgb()) { outputImage[row, col] = new CVRgbPixel(BG_COLOR); } } } // return as a grayscale image. CVImage grayscale = outputImage.ToGrayscale(); outputImage.Release(); return(grayscale); }
private void video_SelectionChanged(object sender, EventArgs f) { if (videoPlayer.LastFrame == null) { return; } using (CVImage region = videoPlayer.LastFrame.CopyRegion(video.SelectionRect)) { selectionHistogram = region.CalcHistogram(30); } ProcessRegionGrowing(); }
/// <summary> /// Can be used in the call to Fill() as the default labeling function. /// This function merely colors the pixel in the color specified under labelCookie /// which should be a Color object. /// </summary> public static void DefaultLabeling(CVImage outputImage, Point pt, object labelCookie) { if (!outputImage.Contains(pt)) { return; } if (outputImage[pt].GrayLevel != 0) { return; } Color c = (Color)labelCookie; outputImage[pt] = new CVRgbPixel(c); }
private void meanShiftNoMask_SelectionChanged(object sender, EventArgs e) { using (CVImage frame = videoPlayer.LastFrame.CopyRegion(meanShiftNoMask.SelectionRect)) { if (histNoMask != null) { histNoMask.Dispose(); } histNoMask = frame.CalcHistogram(Bins); noMaskHist.BinsPerChannel = Bins; noMaskHist.ShowHistogram(frame); } NextFrame(false); }
private void ProcessMeanShift() { if (selectionHistogram == null) { return; } using (CVImage lastFrameClone = videoPlayer.LastFrame.Clone()) { using (CVImage bp = videoPlayer.LastFrame.CalcBackProject(selectionHistogram)) { CVConnectedComp cc = bp.MeanShift(video.SelectionRect, 100); video.SelectionRect = cc.Rect; } } }
private void openVideoToolStripMenuItem_Click(object sender, EventArgs e) { OpenFileDialog openFile = new OpenFileDialog(); openFile.Title = "Select Video File"; openFile.Filter = "AVI Files|*.avi"; if (openFile.ShowDialog() != DialogResult.OK) { return; } cap.Open(openFile.FileName); image = cap.QueryFrame(); UpdateHistogram(); Track(); }
private void openVideoToolStripMenuItem_Click(object sender, EventArgs e) { OpenFileDialog openFile = new OpenFileDialog(); openFile.Title = "Select Video File"; if (openFile.ShowDialog() != DialogResult.OK) { return; } CVCapture cap = new CVCapture(openFile.FileName); image = cap.QueryFrame(); cap.Dispose(); UpdateHistogram(); }
/// <summary> /// Handles the next video frame. /// </summary> private void HandleNextFrame() { if (capture == null) { return; } // release last frame. if (lastFrame != null) { lastFrame.Release(); } // query next frame. lastFrame = capture.QueryFrame(); if (lastFrame == null) { if (loop) { capture.Restart(); lastFrame = capture.QueryFrame(); } else { Pause(); return; } } // put next frame to picture box, if defined. if (pictureBox != null) { pictureBox.Image = lastFrame.ToBitmap(); } // fire event. if (NextFrame != null) { NextFrameEventArgs ea = new NextFrameEventArgs(); ea.Frame = lastFrame; ea.Capture = capture; NextFrame(this, ea); } }
private void ProcessRegionGrowing() { if (selectionHistogram == null) { return; } using (CVImage lastFrameClone = videoPlayer.LastFrame.Clone()) { using (CVImage bp = videoPlayer.LastFrame.CalcBackProject(selectionHistogram)) { CVConnectedComp cc = bp.MeanShift(video.SelectionRect, 100); video.SelectionRect = cc.Rect; Point midPoint = new Point( video.SelectionRect.Left + video.SelectionRect.Width / 2, video.SelectionRect.Top + video.SelectionRect.Height / 2); using (CVImage rg = videoPlayer.Capture.CreateCompatibleImage()) { rg.Zero(); OpenCVDotNet.Algorithms.RegionGrowing.Fill(midPoint, rg, new OpenCVDotNet.Algorithms.RegionGrowingCriteria(MyRGCriteria), videoPlayer.LastFrame); growingFrame.Image = rg.ToBitmap(); if (overlay.Checked) { // go over regions in rg and overlay on output image. for (int row = 0; row < rg.Height; row++) { for (int col = 0; col < rg.Width; ++col) { if (rg[row, col].GrayLevel != 0) { videoPlayer.LastFrame[row, col] = new CVRgbPixel(0, 100, 0); } } } } video.Image = videoPlayer.LastFrame.ToBitmap(); } } } }
public override void Process() { CVImage swap = FPrevious; FPrevious = FCurrent; FCurrent = swap; FInput.Image.GetImage(TColorFormat.L8, FCurrent); Image <Gray, byte> p = FPrevious.GetImage() as Image <Gray, byte>; Image <Gray, byte> c = FCurrent.GetImage() as Image <Gray, byte>; Image <Gray, float> vx = FVelocityX.GetImage() as Image <Gray, float>; Image <Gray, float> vy = FVelocityY.GetImage() as Image <Gray, float>; OpticalFlow.HS(p, c, UsePrevious, vx, vy, FLambda, new MCvTermCriteria(FIterations)); CopyToRgb(); FOutput.Send(); }
private void videoPlayer_Opening(VideoPlayer sender, OpeningEventArgs args) { if (bgFrame != null) { bgFrame.Dispose(); } // create accumulator image when a new video is opened. bgAccum = new double[args.NewCapture.Height, args.NewCapture.Width]; for (int row = 0; row < args.NewCapture.Height; ++row) { for (int col = 0; col < args.NewCapture.Width; ++col) { bgAccum[row, col] = -1.0; } } bgFrame = args.NewCapture.CreateCompatibleImage(); }
public override void Process() { CVImage swap = FPrevious; FPrevious = FCurrent; FCurrent = swap; FInput.Image.GetImage(TColorFormat.L8, FCurrent); Image <Gray, byte> p = FPrevious.GetImage() as Image <Gray, byte>; Image <Gray, byte> c = FCurrent.GetImage() as Image <Gray, byte>; Image <Gray, float> vx = FVelocityX.GetImage() as Image <Gray, float>; Image <Gray, float> vy = FVelocityY.GetImage() as Image <Gray, float>; OpticalFlow.LK(p, c, FWindowSize, vx, vy); CopyToRgb(); FOutput.Send(); }
void DrawHistogram(PictureBox window, CVHistogram histo, int channelIdx) { int imageWidth = window.Width; int imageHeight = window.Height; int bins = histo.BinSizes[0]; int binWidth = imageWidth / bins; if (binWidth <= 0) { binWidth = 1; } CVPair minMax = histo.MinMaxValue; CVImage outputImage = new CVImage(imageWidth, imageHeight, CVDepth.Depth8U, 3); outputImage.Zero(); for (int bin = 0; bin < bins; bin++) { double binValue = histo[bin]; byte level = (byte)CVUtils.Round(binValue * 255 / minMax.Second); byte binHeight = (byte)CVUtils.Round(binValue * imageHeight / minMax.Second); byte[] color = new byte[3]; color[channelIdx] = (byte)(((double)bin / (double)bins) * 255); byte[] markerColor = new byte[3]; markerColor[channelIdx] = level; Color colColor = Color.FromArgb(color[2], color[1], color[0]); Color colMarker = Color.FromArgb(markerColor[2], markerColor[1], markerColor[0]); outputImage.DrawRectangle(new Rectangle(bin * binWidth, imageHeight - binHeight, binWidth - 1, binHeight), colColor); outputImage.DrawRectangle(new Rectangle(bin * binWidth, imageHeight - binHeight, binWidth - 1, binHeight), colMarker); outputImage.DrawRectangle(new Rectangle(bin * binWidth, imageHeight - binHeight, 1, binHeight), colMarker); } window.Image = outputImage.ToBitmap(); outputImage.Release(); }
private void CalculateMaskedHistogram() { if (videoPlayer.LastFrame == null) { return; } using (CVImage frame = videoPlayer.LastFrame.CopyRegion(meanShift.SelectionRect)) { // create a list of real fg and bg markers. List <Point> realFg = new List <Point>(meanShift.GetMarkerLocations(Color.Blue)); List <Point> realBg = new List <Point>(meanShift.GetMarkerLocations(Color.Red)); // create the histogram mask. using (CVImage mask = MaskedHistogram.PrepareMask(frame, realFg.ToArray(), realBg.ToArray(), includeNeautral.Checked, ffThresh.Value)) { maskPicture.Image = mask.ToBitmap(); // show mask histogram to user interface. maskHistogram.BinsPerChannel = Bins; maskHistogram.ShowHistogram(frame, mask); // calculate new histogram (dispose old one if exist). if (hist != null) { hist.Dispose(); } hist = frame.CalcHistogram(Bins, mask); // apply mask to overlay (just for ui). using (CVImage masked = MaskedHistogram.ApplyMask(frame, mask)) { maskOverlay.Image = masked.ToBitmap(); } } } NextFrame(false); }
void DrawHistogram(PictureBox window, CVHistogram histo, int channelIdx) { int imageWidth = window.Width; int imageHeight = window.Height; int bins = histo.BinSizes[0]; int binWidth = imageWidth / bins; if (binWidth <= 0) binWidth = 1; CVPair minMax = histo.MinMaxValue; CVImage outputImage = new CVImage(imageWidth, imageHeight, CVDepth.Depth8U, 3); outputImage.Zero(); for (int bin = 0; bin < bins; bin++) { double binValue = histo[bin]; byte level = (byte)CVUtils.Round(binValue * 255 / minMax.Second); byte binHeight = (byte)CVUtils.Round(binValue * imageHeight / minMax.Second); byte[] color = new byte[3]; color[channelIdx] = (byte)(((double)bin / (double)bins) * 255); byte[] markerColor = new byte[3]; markerColor[channelIdx] = level; Color colColor = Color.FromArgb(color[2], color[1], color[0]); Color colMarker = Color.FromArgb(markerColor[2], markerColor[1], markerColor[0]); outputImage.DrawRectangle(new Rectangle(bin * binWidth, imageHeight - binHeight, binWidth - 1, binHeight), Color.White /* colColor */); outputImage.DrawRectangle(new Rectangle(bin * binWidth, imageHeight - binHeight, binWidth - 1, 1), colMarker); outputImage.DrawRectangle(new Rectangle(bin * binWidth, imageHeight - binHeight, 1, binHeight), colMarker); } window.Image = outputImage.ToBitmap(); outputImage.Release(); }
/// <summary> /// This function applies the mask to image in the following way: /// - All pixels in 'mask' that are blue are copied to the output image in maximum intensity. /// - All pixels in 'mask' that are black are copied to the output image in half intensity. /// - All pixels in 'mask' that are red are not copied at all to output image. /// </summary> public static CVImage ApplyMask(CVImage image, CVImage mask) { CVImage outputImage = image.Clone(); outputImage.Zero(); for (int row = 0; row < image.Height; ++row) { for (int col = 0; col < image.Width; ++col) { // copy everything that's not background. if (mask[row, col].ToColor().ToArgb() != Color.Black.ToArgb()) { outputImage[row, col] = image[row, col]; } else { outputImage[row, col] = new CVRgbPixel(TEMP_BG_COLOR); } } } return(outputImage); }
/// <summary> /// Called by the video player to handle the next video frame. /// </summary> private void videoPlayer1_NextFrame(OpenCVDotNet.UI.VideoPlayer sender, OpenCVDotNet.UI.NextFrameEventArgs args) { // args.Frame contains the frame to be handled. CVImage frame = args.Frame; // go over all the pixels (rows, cols) for (int y = 0; y < frame.Height; ++y) { for (int x = 0; x < frame.Width; ++x) { CVRgbPixel pixel = frame[y, x]; // invert RGB colors. frame[y, x] = new CVRgbPixel( (byte)(255 - pixel.R), (byte)(255 - pixel.G), (byte)(255 - pixel.B)); } } // assign resulting frame to picture box as a bitmap. pictureBox1.Image = frame.ToBitmap(); writer.WriteFrame(frame); }
public void Evaluate(int SpreadMax) { for (int i = SpreadMax; i < FOutput.SliceCount; i++) FOutput[i].Dispose(); while (FOutput.SliceCount < SpreadMax) FOutput.Add(new CVImageLink()); FStatus.SliceCount = SpreadMax; for (int i = 0; i < SpreadMax; i++) { if (!FDo[i]) continue; var inputSpread = FInput[i]; var output = FOutput[i]; foreach(var image in inputSpread) { image.LockForReading(); } CVImage result = new CVImage(); try { int size = inputSpread.SliceCount; Image<Bgr, Byte>[] images = new Image<Bgr, byte>[size]; List<CVImage> ToDispose = new List<CVImage>(); for (int j = 0; j < size; j++) { if (inputSpread[j].FrontImage.ImageAttributes.ColourFormat == TColorFormat.RGB8) { images[j] = inputSpread[j].FrontImage.GetImage() as Image<Bgr, Byte>; } else { var image = new CVImage(); ToDispose.Add(image); image.Initialise(inputSpread[j].FrontImage.Size, TColorFormat.RGB8); inputSpread[j].FrontImage.GetImage(image); images[j] = image.GetImage() as Image<Bgr, Byte>; } } result.SetImage(FStitcher.Stitch(images)); foreach (var image in ToDispose) { image.Dispose(); } FStatus[i] = "OK"; } catch (Exception e) { FStatus[i] = e.Message; } finally { foreach(var image in inputSpread) { image.ReleaseForReading(); } } output.Send(result); } }
/// <summary> /// Implements an 8-connected region growing algorithm based on histogram similarity (using back projection). /// Starts with the starting pixel and checks in the back projection all the four pixel around it. /// If the pixels pass some threshold, they are selected and the region is grown to contain them as well. /// </summary> public static void Fill(Point startPoint, CVImage outputImage, RegionGrowingCriteria criteria, object criteriaCookie) { Fill(startPoint, outputImage, criteria, criteriaCookie, Color.Red); }
public void ShowHistogram(CVImage image) { ShowHistogram(image, null); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////// Bitmap DetectPlate(Bitmap bmp) { CVImage img = new CVImage(bmp); return(img.DetectPlate(true)); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////// public string DetectChar(Bitmap bmp) { //giai đoạn nhận diện ký tự gồm 3 bước: //Bước 1: sắp xếp các ký tự từ trái qua phải //Bước 2: chuyển ảnh ký tự thành tập dữ liệu SVM hợp lệ //Bước 3: nhận diện các tập dữ liệu và nối thành chuỗi kết quả CVImage img = new CVImage(bmp); string chars = img.DetectChar(); int nRects = (chars.Length - chars.Replace("_", "").Length + 1) / 4; if (nRects == 0) { return(""); } List <Rectangle> rects = new List <Rectangle>(nRects); string[] points = chars.Split(new char[] { '_' }); for (int i = 0; i < nRects; i += 1) { Rectangle rect = new Rectangle(int.Parse(points[i * 4 + 0]), int.Parse(points[i * 4 + 1]), int.Parse(points[i * 4 + 2]), int.Parse(points[i * 4 + 3])); rects.Add(rect); } //ảnh các ký tự List <Bitmap> imgkytu = new List <Bitmap>(9); Bitmap Part1 = null; Bitmap Part2 = null; Bitmap Part3 = null; Bitmap Part4 = null; int p1 = 0; //lưu các toạ độ của khung chữ nhật chứa ký tự int[] toado = new int[10]; //sắp xếp các ký tự từ trái qua phải, từ trên xuống dưới for (int i = 0; i < nRects; i++) { Rectangle rect = rects[i]; if (rect.Y < 65 || rect.Y > 165) { if (rect.Y > 170) { imgkytu.Add(Resize(Crop(bmp, rect), new Size(20, 48))); toado[p1] = rect.X; for (int k = 0; k <= p1 - 1; k++) { if (toado[p1] < toado[k]) { Bitmap tempImage = imgkytu[p1]; imgkytu[p1] = imgkytu[k]; imgkytu[k] = tempImage; int temp = toado[p1]; toado[p1] = toado[k]; toado[k] = temp; } } p1 += 1; } else { if (rect.X > 50 && rect.X < 100) { Part1 = Resize(Crop(bmp, rect), new Size(20, 48)); } else if (rect.X > 100 && rect.X < bmp.Width / 2) { Part2 = Resize(Crop(bmp, rect), new Size(20, 48)); } else if (rect.X > bmp.Width / 2 && rect.X < 300) { Part3 = Resize(Crop(bmp, rect), new Size(20, 48)); } else { Part4 = Resize(Crop(bmp, rect), new Size(20, 48)); } } } } string[] temp5 = new string[6]; //chuyển thành tập SVM hợp lệ if (imgkytu != null) { for (int i = 0; i <= p1 - 1; i++) { temp5[i] += ImageToSVMToBinaryString(imgkytu[i]); } } //dự đoán số string result = ""; result += PredictSVM(Part1, "num"); result += PredictSVM(Part2, "num"); result += "-"; result += PredictSVM(Part3, "charnum"); result += PredictSVM(Part4, "charnum"); result += "-"; for (int j = 0; j <= p1 - 1; j++) { result += PredictSVM(temp5[j], g_modelNum); } return(result.Trim()); }
internal __CvImagePtr(CVImage img) : base(true) { SetHandle(img.Ptr); }
private void ResetSegmentation() { segmentationImage = image.Clone(); segPoints = new List <Point>(); }
/// <summary> /// Can be used to implement flood fill. /// </summary> public static bool FloodFillCondition(CVImage frame, Point startPt, Point candidatePt, int tolerange) { if (!frame.Contains(candidatePt) || !frame.Contains(startPt)) return false; return Math.Abs(frame[startPt].GrayLevel - frame[candidatePt].GrayLevel) <= tolerange; }
/// <summary> /// Implements an 8-connected region growing algorithm based on histogram similarity (using back projection). /// Starts with the starting pixel and checks in the back projection all the four pixel around it. /// If the pixels pass some threshold, they are selected and the region is grown to contain them as well. /// </summary> public static void Fill(Point startPoint, CVImage outputImage, RegionGrowingCriteria criteria, object criteriaCookie, Color c) { Fill(startPoint, outputImage, criteria, criteriaCookie, DefaultLabeling, c); }