public KNN(int wantedK, VectorRepository rep) { //k is usually 10 _K = wantedK; _knn = new KNearest(); _repository = rep; }
public void Train(IDictionary<float[], int> trainpairs) { Matrix<float> vectors; Matrix<float> classes; ClassifierUtils.GenerateTrainMatrices(trainpairs, out vectors, out classes); classifier = new KNearest(vectors, classes, null, false, 10); //TODO: set these parameters in Constructor }
public void Train(IDictionary<float[], string> trainpairs) { Matrix<float> vectors; Matrix<float> classes; Dictionary<float[], int> trainers = new Dictionary<float[], int>(trainpairs.Count); InitLookups(trainpairs); foreach (KeyValuePair<float[], string> row in trainpairs) { trainers.Add(row.Key, TUL[row.Value]); } ClassifierUtils.GenerateTrainMatrices(trainers, out vectors, out classes); classifier = new KNearest(vectors, classes, null, false, 10); //TODO: set these parameters in Constructor }
public void Train() { /* * in trainData: data[i,.,.,.] = vector * trainClasses: classes[i] = class */ List<KeyValuePair<ColorPair, CardColor>> pairs = new List<KeyValuePair<ColorPair, CardColor>>(GenerateTrainPairs()); #region Generate the traning data and classes Matrix<float> bgrTraining = new Matrix<float>(pairs.Count, 3); Matrix<float> hsvTraining = new Matrix<float>(pairs.Count, 3); Matrix<float> colorClasses = new Matrix<float>(pairs.Count, 1); for (int i = 0; i < pairs.Count; i++) { bgrTraining[i, 0] = (float)pairs[i].Key.Bgr.Blue; bgrTraining[i, 1] = (float)pairs[i].Key.Bgr.Green; bgrTraining[i, 2] = (float)pairs[i].Key.Bgr.Red; hsvTraining[i, 0] = (float)pairs[i].Key.Hsv.Hue; hsvTraining[i, 1] = (float)pairs[i].Key.Hsv.Satuation; hsvTraining[i, 2] = (float)pairs[i].Key.Hsv.Value; colorClasses[i, 0] = (float)(int)pairs[i].Value; } #endregion bgrClassifier = new KNearest(bgrTraining, colorClasses, null, false, 10); hsvClassifier = new KNearest(hsvTraining, colorClasses, null, false, 10); try { bgrClassifier.Save("bgr.txt"); hsvClassifier.Save("hsv.txt"); } catch (Exception) { } }
public KnnML(string path, int k, ImageVector[] goodImages, ImageVector[] badImages) { this.k = k; type = "KNN"; knn = new KNearest(); this.goodImages = goodImages; this.badImages = badImages; learnedTrue = new bool[goodImages.Length]; learnedFalse = new bool[badImages.Length]; confidenceTrue = new double[goodImages.Length]; confidenceFalse = new double[badImages.Length]; restartTest(); userPath = path + "\\KNN"; resultPath = userPath + "\\" + k; }
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)); } } String knnModelStr; //save stat model to string using (FileStorage fs = new FileStorage(".yml", FileStorage.Mode.Write | FileStorage.Mode.Memory)) { knn.Write(fs); knnModelStr = fs.ReleaseAndGetString(); } //load stat model from string using (FileStorage fs = new FileStorage(knnModelStr, FileStorage.Mode.Read | FileStorage.Mode.Memory)) { KNearest knn2 = new KNearest(); knn2.Read(fs.GetRoot()); } } // 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); }
/////////////////////////////////////////////////////////////////////////////////////////// private void btnOpenTestImage_Click(object sender, EventArgs e) { // note: we effectively have to read the first XML file twice // first, we read the file to get the number of rows (which is the same as the number of samples). // the first time reading the file we can't get the data yet, since we don't know how many rows of data there are // next, reinstantiate our classifications Matrix and training images Matrix with the correct number of rows // then, read the file again and this time read the data into our resized classifications Matrix and training images Matrix Matrix<Single> mtxClassifications = new Matrix<Single>(1, 1); // for the first time through, declare these to be 1 row by 1 column Matrix<Single> mtxTrainingImages = new Matrix<Single>(1, 1); // we will resize these when we know the number of rows (i.e. number of training samples) // possible chars we are interested in are digits 0 through 9 List<int> intValidChars = new List<int> { (int)'0', (int)'1', (int)'2', (int)'3', (int)'4', (int)'5', (int)'6', (int)'7', (int)'8', (int)'9' }; XmlSerializer xmlSerializer = new XmlSerializer(mtxClassifications.GetType()); // these variables are for StreamReader streamReader; // reading from the XML files try { streamReader = new StreamReader("classifications.xml"); // attempt to open classifications file } catch(Exception ex) { // if error is encountered, show error and return txtInfo.Text = Environment.NewLine + txtInfo.Text + "unable to open 'classifications.xml', error:" + Environment.NewLine; txtInfo.Text = txtInfo.Text + ex.Message + Environment.NewLine + Environment.NewLine; return; } // read from the classifications file the 1st time, this is only to get the number of rows, not the actual data mtxClassifications = (Matrix<Single>)xmlSerializer.Deserialize(streamReader); streamReader.Close(); // close the classifications XML file intNumberOfTrainingSamples = mtxClassifications.Rows; // get the number of rows, i.e. the number of training samples // now that we know the number of rows, reinstantiate classifications Matrix and training images Matrix with the actual number of rows mtxClassifications = new Matrix<Single>(intNumberOfTrainingSamples, 1); mtxTrainingImages = new Matrix<Single>(intNumberOfTrainingSamples, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT); try { streamReader = new StreamReader("classifications.xml"); // attempt to reinitialize the stream reader } catch (Exception ex) { // if error is encountered, show error and return txtInfo.Text = Environment.NewLine + txtInfo.Text + "unable to open 'classifications.xml', error:" + Environment.NewLine; txtInfo.Text = txtInfo.Text + ex.Message + Environment.NewLine + Environment.NewLine; return; } // read from the classifications file again, this time we can get the actual data mtxClassifications = (Matrix<Single>)xmlSerializer.Deserialize(streamReader); streamReader.Close(); // close the classifications XML file xmlSerializer = new XmlSerializer(mtxTrainingImages.GetType()); // reinstantiate file reading variables try { streamReader = new StreamReader("images.xml"); } catch (Exception ex) { // if error is encountered, show error and return txtInfo.Text = Environment.NewLine + txtInfo.Text + "unable to open 'images.xml', error:" + Environment.NewLine; txtInfo.Text = txtInfo.Text + ex.Message + Environment.NewLine + Environment.NewLine; return; } mtxTrainingImages = (Matrix<Single>)xmlSerializer.Deserialize(streamReader); // read from training images file streamReader.Close(); // close the training images XML file // train ////////////////////////////////////////////////////////// KNearest kNearest = new KNearest(); // instantiate KNN object kNearest.Train(mtxTrainingImages, mtxClassifications, null, false, 1,false); // call to train // test /////////////////////////////////////////////////////////////////////// DialogResult drChosenFile; drChosenFile = ofdOpenFile.ShowDialog(); // open file dialog if (drChosenFile != DialogResult.OK || ofdOpenFile.FileName == "") { // if user chose Cancel or filename is blank . . . lblChosenFile.Text = "file not chosen"; // show error message on label return; // and exit function } Image<Bgr, Byte> imgTestingNumbers; // this is the main input image try { imgTestingNumbers = new Image<Bgr, Byte>(ofdOpenFile.FileName); // open image } catch(Exception ex) { // if error occurred lblChosenFile.Text = "unable to open image, error: " + ex.Message; // show error message on label return; // and exit function } if(imgTestingNumbers == null) { //if image could not be opened lblChosenFile.Text = "unable to open image"; // show error message on label return; // and exit function } lblChosenFile.Text = ofdOpenFile.FileName; // update label with file name Image<Gray, Byte> imgGrayscale; // Image<Gray, Byte> imgBlurred; // declare various images Image<Gray, Byte> imgThresh; // Image<Gray, Byte> imgThreshCopy; // Contour<Point> contours; imgGrayscale = imgTestingNumbers.Convert<Gray, Byte>(); // convert to grayscale imgBlurred = imgGrayscale.SmoothGaussian(5); // blur // filter image from grayscale to black and white imgThresh = imgBlurred.ThresholdAdaptive(new Gray(255), ADAPTIVE_THRESHOLD_TYPE.CV_ADAPTIVE_THRESH_GAUSSIAN_C, THRESH.CV_THRESH_BINARY_INV, 11, new Gray(2)); imgThreshCopy = imgThresh.Clone(); // make a copy of the thresh image, this in necessary b/c findContours modifies the image // get external countours only contours = imgThreshCopy.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_EXTERNAL); List<Contour<Point> > listOfContours = new List<Contour<Point> >(); // declare a list of contours and a list of valid contours, List<Contour<Point> > listOfValidContours = new List<Contour<Point> >(); // this is necessary for removing invalid contours and sorting from left to right // populate list of contours while(contours != null) { // for each contour Contour<Point> contour = contours.ApproxPoly(contours.Perimeter * 0.0001); // get the current contour, note that the lower the multiplier, the higher the precision listOfContours.Add(contour); // add to list of contours contours = contours.HNext; // move on to next contour } // this next loop removes the invalid contours foreach (Contour<Point> contour in listOfContours) {// for each contour if(ContourIsValid(contour)) {// if contour is valid listOfValidContours.Add(contour);// add to list of valid contours } } // sort contours from left to right listOfValidContours.Sort((oneContour, otherContour) => oneContour.BoundingRectangle.X.CompareTo(otherContour.BoundingRectangle.X)); String strFinalString = ""; // declare final string, this will have the final number sequence by the end of the program foreach (Contour<Point> contour in listOfValidContours) { // for each contour in list of valid contours Rectangle rect = contour.BoundingRectangle; // get the bounding rect imgTestingNumbers.Draw(rect, new Bgr(Color.Green), 2); // draw green rect around the current char Image<Gray, Byte> imgROI = imgThresh.Copy(rect); // get ROI image of bounding rect // resize image, this is necessary for recognition Image<Gray, Byte> imgROIResized = imgROI.Resize(RESIZED_IMAGE_WIDTH, RESIZED_IMAGE_HEIGHT, INTER.CV_INTER_LINEAR); Matrix<Single> mtxTemp = new Matrix<Single>(imgROIResized.Size); // declare a Matrix of the same dimensions as the Image we are adding to the data structure of training images Matrix<Single> mtxTempReshaped = new Matrix<Single>(1, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT); // declare a flattened (only 1 row) matrix of the same total size CvInvoke.cvConvert(imgROIResized, mtxTemp); // convert Image to a Matrix of Singles with the same dimensions for(int intRow = 0; intRow < RESIZED_IMAGE_HEIGHT; intRow++){ // flatten Matrix into one row by RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT number of columns for(int intCol = 0; intCol < RESIZED_IMAGE_WIDTH; intCol++) { mtxTempReshaped[0, (intRow * RESIZED_IMAGE_WIDTH) + intCol] = mtxTemp[intRow, intCol]; } } Single sngCurrentChar = kNearest.FindNearest(mtxTempReshaped, 1, null, null, null, null); // finally we can call find_nearest !!! strFinalString = strFinalString + Convert.ToChar(Convert.ToInt32(sngCurrentChar)); // append current char to full string } // end foreach // show the full string txtInfo.Text = Environment.NewLine + Environment.NewLine + txtInfo.Text + "number read from image = " + strFinalString + Environment.NewLine; CvInvoke.cvShowImage("imgTestingNumbers", imgTestingNumbers); // show input image with green boxes drawn around found digits }
private Image<Bgr, Byte> knn() { int K = 10; int trainSampleCount = 150; int sigma = 60; #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 / 3, 1); trainData1.GetCols(0, 1).SetRandNormal(new MCvScalar(100), new MCvScalar(sigma)); trainData1.GetCols(1, 2).SetRandNormal(new MCvScalar(300), new MCvScalar(sigma)); Matrix<float> trainData2 = trainData.GetRows(trainSampleCount / 3, 2 * trainSampleCount / 3, 1); trainData2.SetRandNormal(new MCvScalar(400), new MCvScalar(sigma)); Matrix<float> trainData3 = trainData.GetRows(2 * trainSampleCount / 3, trainSampleCount, 1); trainData3.GetCols(0, 1).SetRandNormal(new MCvScalar(300), new MCvScalar(sigma)); trainData3.GetCols(1, 2).SetRandNormal(new MCvScalar(100), new MCvScalar(sigma)); Matrix<float> trainClasses1 = trainClasses.GetRows(0, trainSampleCount / 3, 1); trainClasses1.SetValue(1); Matrix<float> trainClasses2 = trainClasses.GetRows(trainSampleCount / 3, 2 * trainSampleCount / 3, 1); trainClasses2.SetValue(2); Matrix<float> trainClasses3 = trainClasses.GetRows(2 * trainSampleCount / 3, trainSampleCount, 1); trainClasses3.SetValue(3); #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(trainData, trainClasses, null, false, K)) { using (KNearest knn = new KNearest()) { bool trained = knn.Train(trainData, trainClasses, null, false, K, false); 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; //Matrix<float> nearestNeighbors = new Matrix<float>(K* sample.Rows, sample.Cols); // estimates the response and get the neighbors' labels float response = 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, 60, 0)) : // (accuracy > 5 ? new Bgr(0, 90, 0) : new Bgr(60, 90, 0)); img[i, j] = response == 1 ? (accuracy > 5 ? new Bgr(90, 0, 0) : new Bgr(90, 30, 30)) : response == 2 ? (accuracy > 5 ? new Bgr(0, 90, 0) : new Bgr(30, 90, 30)) : (accuracy > 5 ? new Bgr(0, 0, 90) : new Bgr(30, 30, 90)); } } knn.Save(@"D:\Play Data\KNN训练数据"); } // display the original training samples for (int i = 0; i < (trainSampleCount / 3); 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); PointF p3 = new PointF(trainData3[i, 0], trainData3[i, 1]); img.Draw(new CircleF(p3, 2.0f), new Bgr(100, 100, 255), -1); } return img; }
private void TestEmgu() { int K = 10; //int trainSampleCount = 100; int trainSampleCount = this.vectorTable[0].Length-1; int trainSampleColumns = this.vectorTable.Length - 2; //subtract two columns for the post id and IsImage int scalingRatio = 10; #region Generate the traning data and classes Matrix<float> trainData = new Matrix<float>(trainSampleColumns, trainSampleCount); Matrix<float> trainClasses = new Matrix<float>(trainSampleColumns, 1); Image<Bgr, Byte> img = new Image<Bgr, byte>(trainSampleCount, trainSampleCount); Matrix<float> sample = new Matrix<float>(1, trainSampleCount); for (int y = 1; y < this.vectorTable[0].Length - 1; y++) { for (int x = 2; x < this.vectorTable.Length - 1; x++) { trainData.Data.SetValue(Int32.Parse(this.vectorTable[x][y])*scalingRatio,x-2,y-1); } } Matrix<float> trainData1 = trainData.GetRows(0, trainSampleColumns >> 1, 1); //trainData1.SetRandNormal(new MCvScalar(200), new MCvScalar(50)); Matrix<float> trainData2 = trainData.GetRows(trainSampleColumns >> 1, trainSampleColumns, 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); KNearest knn = new KNearest(trainData, trainClasses, null, false, K); 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; //Matrix<float> nearestNeighbors = new Matrix<float>(K* sample.Rows, sample.Cols); // estimates the response and get the neighbors' labels float response = 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, 60, 0)) : (accuracy > 5 ? new Bgr(0, 90, 0) : new Bgr(60, 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); Emgu.CV.UI.ImageViewer imgviewer = new Emgu.CV.UI.ImageViewer(img); imgviewer.Show(); }
//load knn training data private void init_KNN() { String folder = "C:\\KinectImage\\rightHand\\palm_small"; String[] filePaths = Directory.GetFiles(folder); int BWImageWidth = 50; trainData = new Matrix<float>(trainSampleCount, BWImageWidth * BWImageWidth); trainClasses = new Matrix<float>(trainSampleCount, 1); int fileIdx = 0; int sampleIdx = 0; for (fileIdx = 0; fileIdx < filePaths.Length; fileIdx++) { Image<Gray, Byte> img = new Image<Gray, Byte>(filePaths[fileIdx]); for (int rowIdx = 0; rowIdx < BWImageWidth; rowIdx++) { for (int colIdx = 0; colIdx < BWImageWidth; colIdx++) { //Console.WriteLine(filePaths[fileIdx]); trainData[sampleIdx, BWImageWidth * rowIdx + colIdx] = (float)img[rowIdx, colIdx].MCvScalar.v0; trainClasses[sampleIdx, 0] = 0.0f; //Console.WriteLine((float)img[rowIdx, colIdx].MCvScalar.v0); } } sampleIdx++; } //read fist folder = "C:\\KinectImage\\rightHand\\fist_small"; filePaths = Directory.GetFiles(folder); for (fileIdx = 0; fileIdx < filePaths.Length; fileIdx++) { Image<Gray, Byte> img = new Image<Gray, Byte>(filePaths[fileIdx]); for (int rowIdx = 0; rowIdx < BWImageWidth; rowIdx++) { for (int colIdx = 0; colIdx < BWImageWidth; colIdx++) { //Console.WriteLine(filePaths[fileIdx]); trainData[sampleIdx, BWImageWidth * rowIdx + colIdx] = (float)img[rowIdx, colIdx].MCvScalar.v0; trainClasses[sampleIdx, 0] = 1.0f; //Console.WriteLine((float)img[rowIdx, colIdx].MCvScalar.v0); } } sampleIdx++; } testSample = new Matrix<float>(1, BWImageWidth * BWImageWidth); results = new Matrix<float>(testSample.Rows, 1); neighborResponses = new Matrix<float>(testSample.Rows, K); knn = new KNearest(trainData, trainClasses, null, false, K); /* //testing folder = "C:\\KinectImage\\rightHand\\palm_small"; filePaths = Directory.GetFiles(folder); for (fileIdx = 0; fileIdx < filePaths.Length; fileIdx++) { Image<Gray, Byte> img = new Image<Gray, Byte>(filePaths[fileIdx]); for (int rowIdx = 0; rowIdx < BWImageWidth; rowIdx++) { for (int colIdx = 0; colIdx < BWImageWidth; colIdx++) { testSample[0, rowIdx*BWImageWidth + colIdx] = (float)img[rowIdx, colIdx].MCvScalar.v0; } } float response = knn.FindNearest(testSample, K, results, null, neighborResponses, null); Console.WriteLine(response); } * */ }
public override bool Predict(List<ImageVector> Vectors, out double[] results) { Boolean forTesting = true; string[] cVectors = new string[Vectors.Count]; for (int i = 0; i < Vectors.Count; i++) cVectors[i] = Classifier.ClassifyVector(Vectors[i]); Image<Bgr, Byte> img = new Image<Bgr, byte>(500, 500); Matrix<float> sample; Matrix<float> res, neighborResponses; Matrix<float> kNearestNeighbors = new Matrix<float>(_K,cVectors.Length); ; results = new double[cVectors.Length]; res = new Matrix<float>(1,1); neighborResponses = new Matrix<float>(1, _K); //dist = new Matrix<float>(1, _K); //load knn repository if (forTesting) _testingRepository.loadList(); else _repository.loadList(); //calculate proportion of false vs. true in repository int f,t; if (forTesting) { f = _testingRepository.VectorListFalse.Count; t = _testingRepository.VectorListTrue.Count; } else { f = _repository.VectorListFalse.Count; t = _repository.VectorListTrue.Count; } double proportion = t / f; //TODO:use this string[] cVectorsTrue, cVectorsFalse; if(forTesting) Classifier.Classify(_testingRepository.VectorListTrue, _testingRepository.VectorListFalse, out cVectorsTrue, out cVectorsFalse); else Classifier.Classify(_repository.VectorListTrue, _repository.VectorListFalse, out cVectorsTrue, out cVectorsFalse); // Push vectors to algorithm convertDataVectorsToMatrix(cVectorsTrue, cVectorsFalse, out _data, out _response); using (_knn = new KNearest(_data, _response, null, false, _K)) { // } int tr=0; for (int i = 0; i < cVectors.Length; i++) { // Convert vector i to matrix convertSampleToMatrix(cVectors[i], out sample); //Matrix<float> nearestNeighbors = new Matrix<float>(K* sample.Rows, sample.Cols); // estimates the response and get the neighbors' labels try { float response = _knn.FindNearest(sample, _K, res, null, neighborResponses, null); if (response == 1) { //System.Windows.Forms.MessageBox.Show("distance " + dist.ToString()); tr++; } double accuracy = 0;//grade of picture double distance = 0; //double power = 0; //double good = 0; // compute the number of neighbors representing the majority int place = 0; for (int k = 0; k < _K; k++) { if (neighborResponses.Data[0, k] == response) accuracy++; } if ((accuracy >= _K / 2)) { if (MainForm.weight == true) { distance = find_weight_distance(cVectors[place], sample, _data); place++; } else { distance = find_distance(cVectors[place], sample, _data); place++; } } else { distance = 1000; place++; } results[i] = distance; accuracy = 0; } catch (Exception e) { System.Windows.Forms.MessageBox.Show(e.Message); } } //System.Windows.Forms.MessageBox.Show(tr+" true images found"); } return true; }