private void Test_KNN() { Matrix <float> MData = null; Matrix <int> MClass = null; List <int> Predictions = new List <int>(); List <int> ActualClasses = new List <int>(); (MData, MClass) = FrameObj.DataToMatrix(TestD); for (int data = 0; data < MData.Rows; data++) { var prediction = KNN.Predict(MData.GetRow(data)); Predictions.Add((int)prediction); ActualClasses.Add(MClass[data, 0]); } var ConfMatrix = OB.ComputeConfusionMatrix(ActualClasses.ToArray(), Predictions.ToArray(), Datasets.Count); var metrics = OB.CalculateMetrics(ConfMatrix, ActualClasses.ToArray(), Predictions.ToArray()); string results = $"Test Samples {ActualClasses.Count} \n Accuraccy = {metrics[0] * 100} % \n " + $"Precission = {metrics[1] * 100} % \n Recall = {metrics[2] * 100} %"; Precision.Content = results; DataTable dataTable = new DataTable(); var collum = OB.CM_Total.GetLength(0); var row = OB.CM_Total.GetLength(1); dataTable.Columns.Add(new DataColumn("")); for (var c = 0; c < collum; c++) { dataTable.Columns.Add(new DataColumn("Class" + c.ToString())); } for (var r = 0; r < row; r++) { var newRow = dataTable.NewRow(); newRow[0] = "Class" + r; for (var c = 0; c < collum; c++) { newRow[c + 1] = OB.CM_Total[r, c]; } dataTable.Rows.Add(newRow); } confMat.CMat.ItemsSource = dataTable.DefaultView; foreach (var col in confMat.CMat.Columns) { col.Width = 100; } confMat.CMat.RowHeight = confMat.CMat.Height / (ConfMatrix.GetLength(1) + 2); }
static void train_knn(string fn) { //string fn = @"C:\projects\local\GradeChecker\GradeChecker\bin\Debug\report.json"; try { var jss = new System.Web.Script.Serialization.JavaScriptSerializer(); List <Dictionary <string, object> > datas = jss.Deserialize <List <Dictionary <string, object> > >(System.IO.File.ReadAllText(fn)); string[] keys = testMQ.Properties.Resources.keys.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); Matrix <float> data; Matrix <int> response; load_data(datas.ToArray(), keys, out data, out response); using (KNearest knn = new KNearest()) { //SVMParams p = new SVMParams(); //p.KernelType = Emgu.CV.ML.MlEnum.SVM_KERNEL_TYPE.LINEAR; //p.SVMType = Emgu.CV.ML.MlEnum.SVM_TYPE.C_SVC; //p.C = 1; //p.TermCrit = new MCvTermCriteria(100, 0.00001); //TrainData td = new TrainData(data, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, response); //bool ok = model.TrainAuto(td, 3); bool ok = knn.Train(data, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, response); if (ok) { knn.Save("knn.xml"); Matrix <float> sample; load_test_data(datas.ToArray(), keys, out sample); float r = knn.Predict(sample); } } } catch (Exception) { } }
static void test_knn(string fn) { //string fn = @"C:\projects\local\GradeChecker\GradeChecker\bin\Debug\test.json"; try { var jss = new System.Web.Script.Serialization.JavaScriptSerializer(); List <Dictionary <string, object> > datas = jss.Deserialize <List <Dictionary <string, object> > >(System.IO.File.ReadAllText(fn)); string[] keys = testMQ.Properties.Resources.keys.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); Matrix <float> data; Matrix <int> response; load_data(datas.ToArray(), keys, out data, out response); using (KNearest model = new KNearest()) { model.Load("knn.xml"); for (int i = 0; i < data.Rows; i++) { float r = model.Predict(data.GetRow(i)); Dictionary <string, object> d = datas[i]; System.Console.WriteLine($"imei={d["imei"]}, VZW={d["VZW"]}, FD={grade_level[(int)r]}"); } } } catch (Exception) { } }
static void test_knn_1() { //Regex r = new Regex(@"^Color Temp: (\d+) K - Lux: (\d+) - R: (\d+) G: (\d+) B: (\d+) Rr: (\d+) Gr: (\d+) Br: (\d+) C: (\d+)\s*$"); //string[] lines = System.IO.File.ReadAllLines(@"data\test.txt"); //foreach(string s in lines) //{ // Match m = r.Match(s); // if (m.Success) // { // if (m.Groups.Count > 9) // { // } // } //} string s = "knn.xml"; if (System.IO.File.Exists(s)) { using (KNearest knn = new KNearest()) { knn.Load(s); //bool ok = knn.Train(data, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, response); Matrix <float> sample; test_data(out sample); float r = knn.Predict(sample); } } else { Matrix <float> data; Matrix <float> response; ReadMushroomData(out data, out response); // using (KNearest knn = new KNearest()) { knn.DefaultK = 3; knn.IsClassifier = true; bool ok = knn.Train(data, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, response); if (ok) { knn.Save("knn.xml"); //int cols = data.Cols; //Matrix<float> sample = new Matrix<float>(1, cols); Matrix <float> sample; test_data(out sample); float r = knn.Predict(sample); } } } }
public int GetImageSimilarityFromKNN(KNearest knn, Mat sample, Rectangle roi) { using (Mat sample2 = new Mat(sample, roi)) { CvInvoke.CvtColor(sample2, sample2, ColorConversion.Bgr2Gray); CvInvoke.Threshold(sample2, sample2, 225, 255, ThresholdType.Binary); sample2.ConvertTo(sample2, DepthType.Cv32F); //sample2.CopyToBitmap().Save("ReferenceImages/Suits/_.bmp"); using (Mat sample3 = sample2.Reshape(0, 1)) { return((int)knn.Predict(sample3)); //knn.FindNearest(sample, K, results, null, neighborResponses, null); } } }
}//end public static string recognizeCharsInPlate(Mat imgThresh, List <PossibleChar> listOfMatchingChars) { string strChars = ""; Mat imgThreshColor = new Mat(); listOfMatchingChars.Sort((firstChar, secondChar) => firstChar.boundingRect.X.CompareTo(secondChar.boundingRect.X)); CvInvoke.CvtColor(imgThresh, imgThreshColor, ColorConversion.Gray2Bgr); foreach (PossibleChar currentChar in listOfMatchingChars) { CvInvoke.Rectangle(imgThreshColor, currentChar.boundingRect, SCALAR_GREEN, 2); Mat imgROItoBeCloned = new Mat(imgThresh, currentChar.boundingRect); Mat imgROI = imgROItoBeCloned.Clone(); Mat imgROIResized = new Mat(); CvInvoke.Resize(imgROI, imgROIResized, new Size(RESIZED_CHAR_IMAGE_WIDTH, RESIZED_CHAR_IMAGE_HEIGHT)); Matrix <Single> mtxTemp = new Matrix <Single>(imgROIResized.Size); Matrix <Single> mtxTempReshaped = new Matrix <Single>(1, RESIZED_CHAR_IMAGE_WIDTH * RESIZED_CHAR_IMAGE_HEIGHT); imgROIResized.ConvertTo(mtxTemp, DepthType.Cv32F); for (int intRow = 0; intRow <= RESIZED_CHAR_IMAGE_HEIGHT - 1; intRow++) { for (int intCol = 0; intCol <= RESIZED_CHAR_IMAGE_WIDTH - 1; intCol++) { mtxTempReshaped[0, (intRow * RESIZED_CHAR_IMAGE_WIDTH) + intCol] = mtxTemp[intRow, intCol]; } } Single sngCurrentChar; sngCurrentChar = kNearest.Predict(mtxTempReshaped); strChars = strChars + (char)(Convert.ToInt32(sngCurrentChar)); } //CvInvoke.Imshow("10", imgThreshColor); return(strChars); }//end
public override string Evaluate(TaggedImage dataSample) { float[,] featureVector2D = new float[1, dataSample.FeatureVector.Count]; List <float> featureVector = dataSample.FeatureVector; for (int j = 0; j < featureVector.Count; ++j) { featureVector2D[0, j] = featureVector[j]; } Matrix <float> featureVectorMatrix = new Matrix <float>(featureVector2D); string res = TaggedImage.GetStringFromIndex((int)kNearest.Predict(featureVectorMatrix)); return(res); }
static void test_knn() { Matrix <float> data; Matrix <int> response; ReadColorData(out data, out response); using (KNearest knn = new KNearest()) { knn.DefaultK = 3; knn.IsClassifier = true; bool ok = knn.Train(data, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, response); if (ok) { knn.Save("knn.xml"); //int cols = data.Cols; //Matrix<float> sample = new Matrix<float>(1, cols); Matrix <float> sample; test_data(out sample); float r = knn.Predict(sample); } } }
public void TestKNearest() { int K = 10; int trainSampleCount = 100; #region Generate the training data and classes Matrix <float> trainData = new Matrix <float>(trainSampleCount, 2); Matrix <float> trainClasses = new Matrix <float>(trainSampleCount, 1); Image <Bgr, Byte> img = new Image <Bgr, byte>(500, 500); Matrix <float> sample = new Matrix <float>(1, 2); Matrix <float> trainData1 = trainData.GetRows(0, trainSampleCount >> 1, 1); trainData1.SetRandNormal(new MCvScalar(200), new MCvScalar(50)); Matrix <float> trainData2 = trainData.GetRows(trainSampleCount >> 1, trainSampleCount, 1); trainData2.SetRandNormal(new MCvScalar(300), new MCvScalar(50)); Matrix <float> trainClasses1 = trainClasses.GetRows(0, trainSampleCount >> 1, 1); trainClasses1.SetValue(1); Matrix <float> trainClasses2 = trainClasses.GetRows(trainSampleCount >> 1, trainSampleCount, 1); trainClasses2.SetValue(2); #endregion Matrix <float> results, neighborResponses; results = new Matrix <float>(sample.Rows, 1); neighborResponses = new Matrix <float>(sample.Rows, K); //dist = new Matrix<float>(sample.Rows, K); using (KNearest knn = new KNearest()) { knn.DefaultK = K; knn.IsClassifier = true; knn.Train(trainData, MlEnum.DataLayoutType.RowSample, trainClasses); //ParamDef[] defs = knn.GetParams(); for (int i = 0; i < img.Height; i++) { for (int j = 0; j < img.Width; j++) { sample.Data[0, 0] = j; sample.Data[0, 1] = i; // estimates the response and get the neighbors' labels float response = knn.Predict(sample); //knn.FindNearest(sample, K, results, null, neighborResponses, null); int accuracy = 0; // compute the number of neighbors representing the majority for (int k = 0; k < K; k++) { if (neighborResponses.Data[0, k] == response) { accuracy++; } } // highlight the pixel depending on the accuracy (or confidence) img[i, j] = response == 1 ? (accuracy > 5 ? new Bgr(90, 0, 0) : new Bgr(90, 40, 0)) : (accuracy > 5 ? new Bgr(0, 90, 0) : new Bgr(40, 90, 0)); } } String knnModelStr; //save stat model to string using (FileStorage fs = new FileStorage(".yml", FileStorage.Mode.Write | FileStorage.Mode.Memory)) { knn.Write(fs, "knn"); knnModelStr = fs.ReleaseAndGetString(); } KNearest knn2 = new KNearest(); knn2.LoadFromString(knnModelStr, "knn"); String knnModelStr2 = knn.SaveToString(); KNearest knn3 = new KNearest(); knn3.LoadFromString(knnModelStr2); #if !NETFX_CORE String fileName = "knnModel.xml"; knn.Save(fileName); String text = File.ReadAllText(fileName); #endif } // display the original training samples for (int i = 0; i < (trainSampleCount >> 1); i++) { PointF p1 = new PointF(trainData1[i, 0], trainData1[i, 1]); img.Draw(new CircleF(p1, 2.0f), new Bgr(255, 100, 100), -1); PointF p2 = new PointF(trainData2[i, 0], trainData2[i, 1]); img.Draw(new CircleF(p2, 2.0f), new Bgr(100, 255, 100), -1); } //Emgu.CV.UI.ImageViewer.Show(img); }
public static KeyValuePair <string, bool> RecognizeText(Mat imgInput) { VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint(); List <ContoursWithData> listOfContoursWithData = new List <ContoursWithData>(); // declare a list of contours with data CvInvoke.FindContours(imgInput, contours, null, RetrType.External, ChainApproxMethod.ChainApproxSimple); //imgInput.Save(@"D:\Visual Studio Projects\KNNtrain\Imagini\4\" + i + ".jpg"); //i++; // populate list of contours with data for (int i = 0; i <= contours.Size - 1; i++) // for each contour { if ((CvInvoke.ContourArea(contours[i]) > MIN_CONTOUR_AREA)) { ContoursWithData contourWithData = new ContoursWithData(); // declare new contour with data contourWithData.contour = contours[i]; // populate contour member variable contourWithData.boundingRectangle = CvInvoke.BoundingRectangle(contourWithData.contour); // calculate bounding rectangle contourWithData.dblArea = CvInvoke.ContourArea(contourWithData.contour); // calculate area if (contourWithData.checkIfContourIsValid()) { listOfContoursWithData.Add(contourWithData);// add to list of contours with data } else { if (contourWithData.boundingRectangle.Width > Properties.Settings.Default.boundingRectangleWidthMax) { Mat imgROItoBeCloned = new Mat(imgInput, contourWithData.boundingRectangle); Mat imgROI = imgROItoBeCloned.Clone(); Rectangle rectangleFirst = new Rectangle(0, 0, contourWithData.boundingRectangle.Width / 2, contourWithData.boundingRectangle.Height); Rectangle rectangleSecond = new Rectangle(contourWithData.boundingRectangle.Width / 2, 0, contourWithData.boundingRectangle.Width / 2, contourWithData.boundingRectangle.Height); Mat firstImage = new Mat(imgROI, rectangleFirst); Mat secondImage = new Mat(imgROI, rectangleSecond); VectorOfVectorOfPoint contoursSplitImage = new VectorOfVectorOfPoint(); CvInvoke.FindContours(firstImage, contoursSplitImage, null, RetrType.External, ChainApproxMethod.ChainApproxSimple); for (int j = 0; j <= contoursSplitImage.Size - 1; j++) // for each contour { if ((CvInvoke.ContourArea(contoursSplitImage[j]) > MIN_CONTOUR_AREA)) { ContoursWithData contourWithDataFirstImage = new ContoursWithData(); // declare new contour with data contourWithDataFirstImage.contour = contoursSplitImage[j]; // populate contour member variable contourWithDataFirstImage.boundingRectangle = CvInvoke.BoundingRectangle(contourWithDataFirstImage.contour); // calculate bounding rectangle contourWithDataFirstImage.boundingRectangle.X = contourWithData.boundingRectangle.X; contourWithDataFirstImage.boundingRectangle.Y = contourWithData.boundingRectangle.Y; contourWithDataFirstImage.dblArea = CvInvoke.ContourArea(contourWithDataFirstImage.contour); // calculate area if (contourWithDataFirstImage.checkIfContourIsValid()) { listOfContoursWithData.Add(contourWithDataFirstImage);// add to list of contours with data } } } contoursSplitImage = new VectorOfVectorOfPoint(); CvInvoke.FindContours(secondImage, contoursSplitImage, null, RetrType.External, ChainApproxMethod.ChainApproxSimple); for (int j = 0; j <= contoursSplitImage.Size - 1; j++) // for each contour { if ((CvInvoke.ContourArea(contoursSplitImage[j]) > MIN_CONTOUR_AREA)) { ContoursWithData contourWithDataSecondImage = new ContoursWithData(); // declare new contour with data contourWithDataSecondImage.contour = contoursSplitImage[j]; // populate contour member variable contourWithDataSecondImage.boundingRectangle = CvInvoke.BoundingRectangle(contourWithDataSecondImage.contour); // calculate bounding rectangle contourWithDataSecondImage.boundingRectangle.X = contourWithData.boundingRectangle.X + contourWithData.boundingRectangle.Width / 2; contourWithDataSecondImage.boundingRectangle.Y = contourWithData.boundingRectangle.Y; contourWithDataSecondImage.dblArea = CvInvoke.ContourArea(contourWithDataSecondImage.contour); // calculate area if (contourWithDataSecondImage.checkIfContourIsValid()) { listOfContoursWithData.Add(contourWithDataSecondImage);// add to list of contours with data } } } } } } } float averageLocationY = 0; float sumLocationY = 0; foreach (var item in listOfContoursWithData) { sumLocationY += item.boundingRectangle.Y + item.boundingRectangle.Height / 2; } averageLocationY = sumLocationY / listOfContoursWithData.Count; float minLocationY = averageLocationY - 0.15f * averageLocationY; float maxLocationY = averageLocationY + 0.15f * averageLocationY; listOfContoursWithData.RemoveAll(x => minLocationY > x.boundingRectangle.Y + x.boundingRectangle.Height / 2 || maxLocationY < x.boundingRectangle.Y + x.boundingRectangle.Height / 2); // sort contours with data from left to right listOfContoursWithData.Sort((oneContourWithData, otherContourWithData) => oneContourWithData.boundingRectangle.X.CompareTo(otherContourWithData.boundingRectangle.X)); string strFinalString = ""; // declare final string, this will have the final number sequence by the end of the program foreach (ContoursWithData contourWithData in listOfContoursWithData) // for each contour in list of valid contours { CvInvoke.Rectangle(imgInput, contourWithData.boundingRectangle, new MCvScalar(200, 0.0, 0.0), 2); // draw green rect around the current char Mat imgROItoBeCloned = new Mat(imgInput, contourWithData.boundingRectangle); // get ROI image of bounding rect Mat imgROI = imgROItoBeCloned.Clone(); // clone ROI image so we don't change original when we resize Mat imgROIResized = new Mat(); // resize image, this is necessary for char recognition CvInvoke.Resize(imgROI, imgROIResized, new System.Drawing.Size(RESIZED_IMAGE_WIDTH, RESIZED_IMAGE_HEIGHT)); // declare a Matrix of the same dimensions as the Image we are adding to the data structure of training images Matrix <float> mtxTemp = new Matrix <float>(imgROIResized.Size); // declare a flattened (only 1 row) matrix of the same total size Matrix <float> mtxTempReshaped = new Matrix <float>(1, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT); imgROIResized.ConvertTo(mtxTemp, DepthType.Cv32F); // convert Image to a Matrix of Singles with the same dimensions for (int intRow = 0; intRow <= RESIZED_IMAGE_HEIGHT - 1; intRow++) // flatten Matrix into one row by RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT number of columns { for (int intCol = 0; intCol <= RESIZED_IMAGE_WIDTH - 1; intCol++) { mtxTempReshaped[0, (intRow * RESIZED_IMAGE_WIDTH) + intCol] = mtxTemp[intRow, intCol]; } } float sngCurrentChar; sngCurrentChar = kNearest.Predict(mtxTempReshaped); // finally we can call Predict !!! strFinalString = strFinalString + (char)(Convert.ToInt32(sngCurrentChar)); // append current char to full string of chars } bool licensePlateRegex = LicensePlateRegex.MatchRegex(strFinalString); return(new KeyValuePair <string, bool>(strFinalString, licensePlateRegex)); }
///'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' //this is where we apply the actual char recognition public string recognizeCharsInPlate(Mat imgThresh, List <PossibleChar> listOfMatchingChars) { string strChars = ""; //this will be the return value, the chars in the lic plate Mat imgThreshColor = new Mat(); listOfMatchingChars.Sort((oneChar, otherChar) => oneChar.boundingRect.X.CompareTo(otherChar.boundingRect.X)); //sort chars from left to right CvInvoke.CvtColor(imgThresh, imgThreshColor, ColorConversion.Gray2Bgr); //for each char in plate foreach (PossibleChar currentChar in listOfMatchingChars) { CvInvoke.Rectangle(imgThreshColor, currentChar.boundingRect, SCALAR_GREEN, 2); //draw green box around the char Mat imgROItoBeCloned = new Mat(imgThresh, currentChar.boundingRect); //get ROI image of bounding rect Mat imgROI = imgROItoBeCloned.Clone(); //clone ROI image so we don't change original when we resize Mat imgROIResized = new Mat(); //resize image, this is necessary for char recognition CvInvoke.Resize(imgROI, imgROIResized, new Size(RESIZED_CHAR_IMAGE_WIDTH, RESIZED_CHAR_IMAGE_HEIGHT)); //declare a Matrix of the same dimensions as the Image we are adding to the data structure of training images Matrix <float> mtxTemp = new Matrix <float>(imgROIResized.Size); //declare a flattened (only 1 row) matrix of the same total size Matrix <float> mtxTempReshaped = new Matrix <float>(1, RESIZED_CHAR_IMAGE_WIDTH * RESIZED_CHAR_IMAGE_HEIGHT); imgROIResized.ConvertTo(mtxTemp, DepthType.Cv32F); //convert Image to a Matrix of Singles with the same dimensions //flatten Matrix into one row by RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT number of columns for (int intRow = 0; intRow <= RESIZED_CHAR_IMAGE_HEIGHT - 1; intRow++) { for (int intCol = 0; intCol <= RESIZED_CHAR_IMAGE_WIDTH - 1; intCol++) { mtxTempReshaped[0, (intRow * RESIZED_CHAR_IMAGE_WIDTH) + intCol] = mtxTemp[intRow, intCol]; } } float sngCurrentChar = 0; sngCurrentChar = kNearest.Predict(mtxTempReshaped); //finally we can call Predict !!! strChars = strChars + (char)sngCurrentChar; //append current char to full string of chars } // show steps ''''''''''''''''''''''''''''''''' if ((frm.cbShowSteps.Checked == true)) { CvInvoke.Imshow("10", imgThreshColor); } // show steps ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' return(strChars); //return result }
static void check_device_color(System.Collections.Specialized.StringDictionary args) { System.Console.WriteLine($"Open COM port: {args["port"]}."); //1.open serial port try { _port = new System.IO.Ports.SerialPort(args["port"]); //_port = new SerialPort(args["port"], 9600); _port.BaudRate = 9600; _port.Parity = Parity.None; _port.StopBits = StopBits.One; _port.DataBits = 8; _port.Handshake = Handshake.None; _port.RtsEnable = true; _port.DtrEnable = true; _port.ReadTimeout = 1000; _port.WriteTimeout = 1000; _port.DataReceived += _port_DataReceived; _port.Open(); } catch (Exception) { _port = null; System.Console.WriteLine($"Fail to open COM port: {args["port"]}."); goto exit; } DateTime _start = DateTime.Now; bool done = false; System.Console.WriteLine($"Waiting for sensor ready."); //2.wait for sensor ready while (!done) { string s = get_data(); Match m = Regex.Match(s, "Found sensor", RegexOptions.None, Regex.InfiniteMatchTimeout); if (m.Success) { System.Console.WriteLine($"Sensor is ready."); done = true; } if ((DateTime.Now - _start).TotalSeconds > 10) { break; } } if (!done) { System.Console.WriteLine($"Sensor is not ready."); goto exit; } Regex r = new Regex(@"^Color Temp: (\d+) K - Lux: (\d+) - R: (\d+) G: (\d+) B: (\d+) C: (\d+)\s*$"); //3.turn off led System.Console.WriteLine($"Trun off LED."); _port.Write(new byte[] { 0x00 }, 0, 1); System.Console.WriteLine($"Read data for white noise."); System.Console.WriteLine($"Please remove device from sensor, and press any key to continue and q to quit."); ConsoleKeyInfo k = System.Console.ReadKey(); if (k.KeyChar == 'q' || k.KeyChar == 'q') { goto exit; } //4.read data for white noise int samples = 10; int[,] white_noise = new int[samples, 6]; System.Console.WriteLine($"Read {samples} sample data for white noise."); done = false; int i = 0; int[] white_noise_lux = new int[samples]; int[] white_noise_c = new int[samples]; while (!done && i < samples) { System.Threading.Thread.Sleep(1000); string s = get_data(); System.Console.WriteLine($"White noise data: {s}"); Match m = r.Match(s); if (m.Success && m.Groups.Count > 6) { white_noise[i, 0] = Int32.Parse(m.Groups[1].Value); white_noise[i, 1] = Int32.Parse(m.Groups[2].Value); white_noise[i, 2] = Int32.Parse(m.Groups[3].Value); white_noise[i, 3] = Int32.Parse(m.Groups[4].Value); white_noise[i, 4] = Int32.Parse(m.Groups[5].Value); white_noise[i, 5] = Int32.Parse(m.Groups[6].Value); white_noise_lux[i] = white_noise[i, 1]; white_noise_c[i] = white_noise[i, 5]; i++; } } System.Console.WriteLine($"Complete to sample data for white noise."); // MeanStandardDeviation Tuple <double, double> wn_lux = MathNet.Numerics.Statistics.ArrayStatistics.MeanStandardDeviation(white_noise_lux); Tuple <double, double> wn_c = MathNet.Numerics.Statistics.ArrayStatistics.MeanStandardDeviation(white_noise_c); System.Console.WriteLine($"White noise. mean of lux={wn_lux.Item1}, stddev={wn_lux.Item2}"); System.Console.WriteLine($"White noise. mean of C={wn_c.Item1}, stddev={wn_c.Item2}"); // load existing data for knn System.Console.WriteLine("Load training data."); KNearest knn = new KNearest(); done = false; { Matrix <float> trained_data; Matrix <int> response; ReadColorData(out trained_data, out response); //using (KNearest knn = new KNearest()) { knn.DefaultK = 3; knn.IsClassifier = true; bool ok = knn.Train(trained_data, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, response); if (ok) { System.Console.WriteLine("Load training data Success."); done = true; //knn.Save("knn.xml"); //int cols = data.Cols; //Matrix<float> sample = new Matrix<float>(1, cols); //Matrix<float> sample; //test_data(out sample); //float r = knn.Predict(sample); } } } if (!done) { System.Console.WriteLine("Fail to load training data ."); goto exit; } string data = ""; done = false; System.Console.WriteLine($"Check device color. please place devices, press q to quit."); //List<int[]> color_data = new List<int[]>(); int device_stage = 0; while (!done) { System.Threading.Thread.Sleep(1000); if (System.Console.KeyAvailable) { k = System.Console.ReadKey(); if (k.KeyChar == 'q' || k.KeyChar == 'q') { done = true; continue; } } //string data; data = get_data(); Match m = r.Match(data); if (m.Success) { //System.Console.WriteLine($"Data: {data}"); if (m.Groups.Count > 6) { if (device_stage == 0) { // wiat for device in place, // get lux and c int lux = Int32.Parse(m.Groups[2].Value); int c = Int32.Parse(m.Groups[6].Value); double r1 = (wn_lux.Item1 - lux) / wn_lux.Item1; double r2 = (wn_c.Item1 - c) / wn_c.Item1; if (r1 > 0.5 && r2 > 0.5) { // device in place System.Console.WriteLine($"Device In-Place."); device_stage = 1; } } else if (device_stage == 1) { // device in-place // led on. System.Console.WriteLine($"Turn On LED ."); _port.Write(new byte[] { 0xff }, 0, 1); device_stage = 2; System.Threading.Thread.Sleep(2000); } else if (device_stage == 2) { System.Console.WriteLine($"Color Data: {data}"); // save color data //int[] c = new int[6]; //c[0] = Int32.Parse(m.Groups[1].Value); //c[1] = Int32.Parse(m.Groups[2].Value); //c[2] = Int32.Parse(m.Groups[3].Value); //c[3] = Int32.Parse(m.Groups[4].Value); //c[4] = Int32.Parse(m.Groups[5].Value); //c[5] = Int32.Parse(m.Groups[6].Value); //color_data.Add(c); // predict device color string s = parse_color_data(data); Matrix <float> sample; test_data(out sample, s); float idx = knn.Predict(sample); System.Console.WriteLine($"Predict: device color idx is {idx}"); device_stage = 3; } else if (device_stage == 3) { // device in-place // led on. System.Console.WriteLine($"Turn Off LED ."); _port.Write(new byte[] { 0x00 }, 0, 1); device_stage = 4; System.Threading.Thread.Sleep(1000); } else if (device_stage == 4) { System.Console.WriteLine($"Please remove device and place another one."); // wiat for device remove, // get lux and c int lux = Int32.Parse(m.Groups[2].Value); int c = Int32.Parse(m.Groups[6].Value); double r1 = (wn_lux.Item1 - lux) / wn_lux.Item1; double r2 = (wn_c.Item1 - c) / wn_c.Item1; if (r1 < 0.2 && r2 < 0.2) { // device in place System.Console.WriteLine($"Device removed."); device_stage = 0; } } else { } } } } //5.press any key to continue to read device color //6.place device //7.wait for device in-place //8.read data for device color //9.wait for device removal //10.press 'q' to quit or go to 7. //11.done. exit: if (_port != null) { if (_port.IsOpen) { _port.Write(new byte[] { 0x00 }, 0, 1); _port.Close(); } } }
/// Predict gesture from sample public static Gestures Predict(Matrix <float> sample) { return((Gestures)knn.Predict(sample)); }
public void TestKNearest() { int K = 10; int trainSampleCount = 100; #region Generate the training data and classes Matrix <float> trainData = new Matrix <float>(trainSampleCount, 2); Matrix <float> trainClasses = new Matrix <float>(trainSampleCount, 1); Image <Bgr, Byte> img = new Image <Bgr, byte>(500, 500); Matrix <float> sample = new Matrix <float>(1, 2); Matrix <float> trainData1 = trainData.GetRows(0, trainSampleCount >> 1, 1); trainData1.SetRandNormal(new MCvScalar(200), new MCvScalar(50)); Matrix <float> trainData2 = trainData.GetRows(trainSampleCount >> 1, trainSampleCount, 1); trainData2.SetRandNormal(new MCvScalar(300), new MCvScalar(50)); Matrix <float> trainClasses1 = trainClasses.GetRows(0, trainSampleCount >> 1, 1); trainClasses1.SetValue(1); Matrix <float> trainClasses2 = trainClasses.GetRows(trainSampleCount >> 1, trainSampleCount, 1); trainClasses2.SetValue(2); #endregion Matrix <float> results, neighborResponses; results = new Matrix <float>(sample.Rows, 1); neighborResponses = new Matrix <float>(sample.Rows, K); //dist = new Matrix<float>(sample.Rows, K); using (KNearest knn = new KNearest()) { knn.DefaultK = K; knn.IsClassifier = true; knn.Train(trainData, MlEnum.DataLayoutType.RowSample, trainClasses); //ParamDef[] defs = knn.GetParams(); //TODO: find out when knn.save will be implemented //knn.Save("knn.xml"); for (int i = 0; i < img.Height; i++) { for (int j = 0; j < img.Width; j++) { sample.Data[0, 0] = j; sample.Data[0, 1] = i; // estimates the response and get the neighbors' labels float response = knn.Predict(sample); //knn.FindNearest(sample, K, results, null, neighborResponses, null); int accuracy = 0; // compute the number of neighbors representing the majority for (int k = 0; k < K; k++) { if (neighborResponses.Data[0, k] == response) { accuracy++; } } // highlight the pixel depending on the accuracy (or confidence) img[i, j] = response == 1 ? (accuracy > 5 ? new Bgr(90, 0, 0) : new Bgr(90, 40, 0)) : (accuracy > 5 ? new Bgr(0, 90, 0) : new Bgr(40, 90, 0)); } } } // display the original training samples for (int i = 0; i < (trainSampleCount >> 1); i++) { PointF p1 = new PointF(trainData1[i, 0], trainData1[i, 1]); img.Draw(new CircleF(p1, 2.0f), new Bgr(255, 100, 100), -1); PointF p2 = new PointF(trainData2[i, 0], trainData2[i, 1]); img.Draw(new CircleF(p2, 2.0f), new Bgr(100, 255, 100), -1); } //Emgu.CV.UI.ImageViewer.Show(img); }
//Recognize a single digit. public int Recognize(Mat img) { const int RESIZED_IMAGE_WIDTH = 10; const int RESIZED_IMAGE_HEIGHT = 10; int cres = '?'; var mtxClassifications = _responses; int intNumberOfTrainingSamples = mtxClassifications.Rows; mtxClassifications = new Matrix <float>(447, 1); var mtxTrainingImages = new Matrix <float>(447, 100); //TODO: mtxTrainingImages = _samples; // train KNearest kNearest = new KNearest(); kNearest.DefaultK = 1; kNearest.Train(mtxTrainingImages, Emgu.CV.ML.MlEnum.DataLayoutType.RowSample, mtxClassifications); Mat imgTestingNumbers = img; //declare various images Mat imgGrayscale = new Mat(); Mat imgBlurred = new Mat(); Mat imgThresh = new Mat(); Mat imgThreshCopy = new Mat(); //convert to grayscale CvInvoke.CvtColor(imgTestingNumbers, imgGrayscale, ColorConversion.Bgr2Gray); //blur CvInvoke.GaussianBlur(imgGrayscale, imgBlurred, new Size(5, 5), 0); //threshold image from grayscale to black and white CvInvoke.AdaptiveThreshold(imgBlurred, imgThresh, 255.0, AdaptiveThresholdType.GaussianC, ThresholdType.BinaryInv, 11, 2.0); //make a copy of the thresh image, this in necessary b/c findContours modifies the image imgThreshCopy = imgThresh.Clone(); var contours = new VectorOfVectorOfPoint(); //get external countours only CvInvoke.FindContours(imgThreshCopy, contours, null, RetrType.External, ChainApproxMethod.ChainApproxSimple); //declare a list of contours with data var listOfContoursWithData = new List <ContourWithData>(); //populate list of contours with data //for each contour for (int i = 0; i <= contours.Size - 1; i++) { //declare new contour with data ContourWithData contourWithData = new ContourWithData(); //populate contour member variable contourWithData.contour = contours[i]; //calculate bounding rectangle contourWithData.boundingRect = CvInvoke.BoundingRectangle(contourWithData.contour); //calculate area contourWithData.dblArea = CvInvoke.ContourArea(contourWithData.contour); //if contour with data is valid if ((contourWithData.CheckIfContourIsValid())) { //add to list of contours with data listOfContoursWithData.Add(contourWithData); } } //sort contours with data from left to right listOfContoursWithData.Sort((oneContourWithData, otherContourWithData) => oneContourWithData.boundingRect.X.CompareTo(otherContourWithData.boundingRect.X)); //declare final string, this will have the final number sequence by the end of the program string strFinalString = ""; //for each contour in list of valid contours foreach (ContourWithData contourWithData in listOfContoursWithData) { //draw green rect around the current char CvInvoke.Rectangle(imgTestingNumbers, contourWithData.boundingRect, new MCvScalar(0.0, 255.0, 0.0), 2); //get ROI image of bounding rect Mat imgROItoBeCloned = new Mat(imgThresh, contourWithData.boundingRect); //clone ROI image so we don't change original when we resize Mat imgROI = imgROItoBeCloned.Clone(); Mat imgROIResized = new Mat(); //resize image, this is necessary for char recognition CvInvoke.Resize(imgROI, imgROIResized, new Size(RESIZED_IMAGE_WIDTH, RESIZED_IMAGE_HEIGHT)); //declare a Matrix of the same dimensions as the Image we are adding to the data structure of training images Matrix <float> mtxTemp = new Matrix <float>(imgROIResized.Size); //declare a flattened (only 1 row) matrix of the same total size Matrix <float> mtxTempReshaped = new Matrix <float>(1, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT); //convert Image to a Matrix of Singles with the same dimensions imgROIResized.ConvertTo(mtxTemp, DepthType.Cv32F); //flatten Matrix into one row by RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT number of columns for (int intRow = 0; intRow <= RESIZED_IMAGE_HEIGHT - 1; intRow++) { for (int intCol = 0; intCol <= RESIZED_IMAGE_WIDTH - 1; intCol++) { mtxTempReshaped[0, (intRow * RESIZED_IMAGE_WIDTH) + intCol] = mtxTemp[intRow, intCol]; } } float sngCurrentChar = 0; //finally we can call Predict !!! sngCurrentChar = kNearest.Predict(mtxTempReshaped); //append current char to full string of chars strFinalString = strFinalString + (char)sngCurrentChar; } //Console.WriteLine("results: " + results); //Console.WriteLine("neighborResponses: " + neighborResponses); //Console.WriteLine("dists: " + dists); //Console.WriteLine("results: " + results); return(cres); }