def __init__(self, in_queue, out_queue, options): threading.Thread.__init__(self) self.in_queue = in_queue self.out_queue = out_queue self.test_bodypart = None self.bodypart_knn_pos = cv2.KNearest() self.bodypart_knn_neg = cv2.KNearest() self.bodypart_trained_data_pos = None self.bodypart_vote = []
def get_matrix(): chessboard_matrix = init_matrix() train_filename_list, train_label_list = train.find_picture('static/train/') train_file_list = train.preprocess_img(train_filename_list) test_filename_list, test_label_list = train.find_picture( 'static/ClippedImg/') test_file_list = train.preprocess_img(test_filename_list) knn = cv2.KNearest() knn.train(train_file_list, train_label_list) ret, result, neighbours, dist = knn.find_nearest(test_file_list, k=3) for i in range(len(result)): #print int(result[i][0]),test_filename_list[i] if int(result[i][0]) == 1: position = re.search(r'\d{1,2}_\d{1,2}', str(test_filename_list[i])).group().split('_') xposition, yposition = int(position[0]), int(position[1]) chessboard_matrix[xposition][yposition] = 1 if int(result[i][0]) == 2: position = re.search(r'\d{1,2}_\d{1,2}', str(test_filename_list[i])).group().split('_') xposition, yposition = int(position[0]), int(position[1]) chessboard_matrix[xposition][yposition] = 2 # if str(test_filename_list[i]).find('2_2') != -1: # print result[i],test_filename_list[i] return chessboard_matrix
def kNN(trainingData, trainingClasses, testData, testClasses): kNNClassifier = cv2.KNearest() kNNClassifier.train(trainingData, trainingClasses) ret, results, neighbours, dist = kNNClassifier.find_nearest(testData, 3) print results return calculateAccuracy(testClasses, results), calcSensitivity(testClasses, results)
def get_model_and_label_map(source_dir): responses = [] label_map = [] samples = numpy.empty((0, KNN_SQUARE_SIDE * KNN_SQUARE_SIDE), numpy.float32) for label_idx, filename in enumerate(os.listdir(source_dir)): label = filename[:filename.index('.png')] label_map.append(label) responses.append(label_idx) image = cv2.imread(os.path.join(source_dir, filename), 0) suit_image_standard_size = cv2.resize( image, (KNN_SQUARE_SIDE, KNN_SQUARE_SIDE)) sample = suit_image_standard_size.reshape( (1, KNN_SQUARE_SIDE * KNN_SQUARE_SIDE)) samples = numpy.append(samples, sample, 0) responses = numpy.array(responses, numpy.float32) responses = responses.reshape((responses.size, 1)) model = cv2.KNearest() model.train(samples, responses) return model, label_map
def initKNN(self): print "Initialising letter classifier" self.kNN = cv2.KNearest() scriptdir = os.path.dirname(os.path.realpath(__file__)) with np.load(scriptdir + '/knn.npz') as data: self.kNN.train(data['images'], data['letters']) print "Initialised letter classifier."
def learn_from_pic(self, path_to_files, clear_all, to_save, to_train): # do you want to start from zero? # True: clear all # False -> just continue if (clear_all): self.samples = np.empty((0, self.roisize * self.roisize)) self.responses = [] self.model = 0 self.model = cv2.KNearest() # make samples and responses cv2.namedWindow('norm', cv2.WINDOW_NORMAL) cv2.namedWindow('small', cv2.WINDOW_NORMAL) for img_path in path_to_files: imag = cv2.imread(img_path) binary = self.im_preprocess(imag) self.process_learning(imag, binary) cv2.destroyWindow('norm') cv2.destroyWindow('small') # ask for saving data # True -> save data # False -> nothing happens if (to_save): path_1 = self.path + 'samples_1.data' path_2 = self.path + 'responses_1.data' self.save_learned(path_1, path_2) # ask to train model on current datas # Y -> self.model.train(self.samples,self.responses) # N -> program ends if (to_train): responses = np.array(self.responses, np.float32) responses = responses.reshape((responses.size, 1)) samples = np.array(self.samples, np.float32) self.model.train(samples, responses)
def eval(self, knn_k=-1, Kpca=-1): if knn_k <= 0: knn_k = self.knn knn_k += 1 # exclude itself if Kpca < 0: Kpca = self.K responses = [] for name, img, label in self.image_dictionary: responses.append(label) knn = cv2.KNearest() knn.train(self.weightTraining[0:Kpca, :].T.astype(np.float32), np.asarray(responses, dtype=np.float32)) # we have to discard the first predict result, since it has to be itself ret, results, neighbours2, dist = knn.find_nearest( self.weightTraining[0:Kpca, :].T.astype(np.float32), knn_k) neighbours = neighbours2[:, 1:] eval_data = [] for idx, nb in enumerate(neighbours): neighbours_count = [] for n in nb: neighbours_count.append(nb.tolist().count(n)) vote = nb[neighbours_count.index(max(neighbours_count))] eval_data.append((vote, responses[idx])) #print ("predict:%s, neight: %s, label: %d" % (str(vote),str(nb), responses[idx])) return eval_data
def demo_digits(): img = cv2.imread("digits.png") gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) cells = [np.hsplit(row, 100) for row in np.vsplit(gray, 50)] x = np.array(cells) train = x[:, :50].reshape(-1, 400).astype(np.float32) test = x[:, 50:100].reshape(-1, 400).astype(np.float32) k = np.arange(10) train_labels = np.ndarray.flatten(np.repeat(k, 250)[:, np.newaxis]) test_labels = train_labels.copy() # print(np.shape(train)) # print(np.shape(train_labels)) knn = cv2.KNearest() knn.train(train, train_labels) ret, result, neighbors, dist = knn.find_nearest(test, k=5) result = np.ndarray.flatten(result) # print result # print test_labels matches = (result == test_labels) correct = np.count_nonzero(matches) accuracy = correct * 100.0 / result.size print accuracy
def loadDatabase(dirName): print "Loading images from the object database..." files = os.listdir(dirName) sift = cv2.SIFT() Id = 0 objKeyptDescr = [] #np.ndarray(shape=(0, 128), dtype=np.float32) """Format: List of descriptors""" labelIds = [] #np.ndarray(shape=(0), dtype=np.int) """Label ids for the descriptors""" global labels, noKeypoints for name in files: (shortname, extension) = os.path.splitext(name) if extension in ['.jpg', '.png', '.jpeg']: print "Loading ", shortname, "..." img = cv2.imread(os.path.join(dirName, name))#, cv2.IMREAD_GRAYSCALE) #cv2.imshow(shortname,img) kp, descrs = sift.detectAndCompute(img, None) for d in descrs: objKeyptDescr += [d]#np.append(objKeyptDescr, d) labelIds += [Id]#np.append(labelIds, Id) labels += [shortname] noKeypoints += [len(descrs)] Id += 1 global classifier classifier = cv2.KNearest() classifier.train(np.array(objKeyptDescr),np.array(labelIds))
def main(): # Training set of 20 random (x, y) values, x,y is between 0 and 49 train_data = np.random.randint(0, MAX_INT, (DATA_SIZE, 2)).astype(np.float32) # Labels for each value in the training set - 0 for red, 1 for blue labels = np.random.randint(0, 2, (DATA_SIZE, 1)).astype(np.float32) # Red data: take all training data with label 0 red = train_data[labels.ravel() == 0] # Plot: x points, y points, s - size of points, # c - color, marker - the shape plt.scatter(red[:, 0], red[:, 1], s=100, c='r', marker='^') # Blue data: take all training data with label 1 blue = train_data[labels.ravel() == 1] plt.scatter(blue[:, 0], blue[:, 1], s=100, c='b', marker='s') # Green data: A single random (x, y) for input data input_data = np.random.randint(0, MAX_INT, (1, 2)).astype(np.float32) plt.scatter(input_data[:, 0], input_data[:, 1], s=100, c='g', marker='o') knn = cv2.KNearest() knn.train(train_data, labels) # Find k=3 nearest neighbours and classify the given input data retval, results, neighbours, dists = knn.find_nearest(input_data, k=3) classified_label = get_human_label(results[0][0]) print('The input point (%s, %s) is %s' % (input_data[0][0], input_data[0][1], classified_label)) for i, neighbour in enumerate(neighbours[0].tolist()): print('Neightbour #%s is %s, distance to point: %s' % (i + 1, get_human_label(neighbour), dists[0][i])) plt.show()
def __init__(self, keypoints, descriptors, referencePointYX, bounds, eye1, eye2): """ takes keypoints and descriptors for an image, and sets up the internals of the class as though it's just been run. internals: knn classifier reference point the main array of descriptors is also set up, with: descriptors vector to virtual point matchedLocation: (None if not matched) weight as representation may change, setters and gettters should be used """ self.reference = referencePointYX assert(len(descriptors) > 0) self.rowsize = len(descriptors) / len(keypoints) #this doesn't need to be self.saved here now, but I may want it later: keypoints, self.descriptors = self.cropToBounds(keypoints, descriptors, bounds, eye1, eye2) labels = np.arange(len(keypoints), dtype = np.float32) self.oldknn = cv2.KNearest() #train the KNN matcher self.oldknn.train(self.descriptors, labels) self.keypointdata = [] for kp in keypoints: vector = (self.reference[0] - kp.pt[0], self.reference[1] - kp.pt[1]) data = self.mykeypoint(vector = vector) self.keypointdata.append(data)
def test_scanner(): ####### training part ############### samples = np.loadtxt('generalsamples.data',np.float32) responses = np.loadtxt('generalresponses.data',np.float32) responses = responses.reshape((responses.size,1)) model = cv2.KNearest() model.train(samples,responses) ############################# testing part ######################### test_image_path = image_dir+'digits-test-1.png' im = cv2.imread(test_image_path) out = np.zeros(im.shape,np.uint8) gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY) thresh = cv2.adaptiveThreshold(gray,255,1,1,11,2) contours,hierarchy = cv2.findContours(thresh,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: if cv2.contourArea(cnt)>50: [x,y,w,h] = cv2.boundingRect(cnt) if h>28: cv2.rectangle(im,(x,y),(x+w,y+h),(0,255,0),2) roi = thresh[y:y+h,x:x+w] roismall = cv2.resize(roi,(10,10)) roismall = roismall.reshape((1,100)) roismall = np.float32(roismall) retval, results, neigh_resp, dists = model.find_nearest(roismall, k = 1) string = str(int((results[0][0]))) cv2.putText(out,string,(x,y+h),0,1,(0,255,0)) cv2.imshow('im',im) cv2.imshow('out',out) cv2.waitKey(0)
def get_knn(): from glob import glob import os x = np.zeros((10, 224, 20, 20)) for i in range(10): print i folder = "images/pdf2png/%d/" % i files = glob(folder + "*.png") for file in files: fname = os.path.basename(file) idx = int(fname[:4]) img = cv2.imread(file, 0) x[i, idx, :, :] = img # Make it into a Numpy array. It size will be (50,100,20,20) # x = np.array(cells) # Now we prepare train_data and test_data. train = x[:, :112].reshape(-1, 400).astype(np.float32) # Size = (1120,400) test = x[:, 112:224].reshape(-1, 400).astype(np.float32) # Size = (1120,400) # Create labels for train and test data k = np.arange(10) train_labels = np.repeat(k, 112)[:, np.newaxis] test_labels = train_labels.copy() # Initiate kNN, train the data, then test it with test data for k=1 knn = cv2.KNearest() knn.train(train, train_labels) return knn
def knn(): total_samples = len(glob.glob("images/training_data/**/*")) samples = np.zeros((total_samples, FEATURE_LENGTH), dtype=np.float32) responses = [] training_folders = glob.glob("images/training_data/*") i = 0 for f in training_folders: piece_type = f[21:] for training_image in glob.glob(f + "/*"): img = cv2.imread(training_image) samples[i] = image_feature(img) i += 1 responses.append(ord(piece_type)) responses = np.array(responses, dtype=np.float32) responses = responses.reshape((responses.size, 1)) test_samples = samples[-10:] test_responses = responses[-10:] samples = samples[:-10] responses = responses[:-10] knn = cv2.KNearest() knn.train(samples, responses) return knn
def __init__(self, trainName, testName, save = 0): self.save = save self.trainName = trainName self.testName = testName self.trainData = np.empty(shape = [0, 3]) self.testData = self.trainData.copy() self.knn = cv2.KNearest()
def demo_alphabet(): data = np.loadtxt('letter-recognition.data', dtype='float32', delimiter=',', converters={0: lambda ch: ord(ch) - ord('A')}) train, test = np.vsplit(data, 2) responses, trainData = np.hsplit(train, [1]) labels, testData = np.hsplit(test, [1]) # print labels # # print np.shape(trainData) # print np.shape(testData) # # print np.shape(responses) # print np.shape(labels) knn = cv2.KNearest() knn.train(trainData, responses) ret, result, neighbors, dist = knn.find_nearest(testData, k=5) # result = np.ndarray.flatten(result) # print(result) correct = np.count_nonzero(result == labels) accuracy = correct * 100.0 / 10000 print accuracy
def learn_digits(self): train_digits = mnist.read("training") k_number = [] k_label = [] for i in range(5000): k = train_digits.next() k_label.append(k[0]) k_number.append(k[1]) y = np.array(list(k_label)) x = np.array(list(k_number)) print y[0] print x[0] # Now we prepare train_data and test_data. train = x[:5000].reshape(-1, 784).astype(np.float32) # Create labels for train and test data k = np.arange(10) train_labels = y[:5000].astype(np.int) # Initiate kNN, train the data, then test it with test data for k=1 knn = cv2.KNearest() knn.train(train, train_labels) number = self.edit_image(self.snap()) number = number.reshape(-1, 784).astype(np.float32) nparray = np.array(number) ret2, result2, neighbours2, dist2 = knn.find_nearest(nparray, k=5) print result2
def createDigitsModel(fontfile, digitheight): font = ImageFont.truetype(fontfile, digitheight) samples = np.empty((0, digitheight * (digitheight / 2))) responses = [] for n in range(10): pil_im = Image.new("RGB", (digitheight, digitheight * 2)) ImageDraw.Draw(pil_im).text((0, 0), str(n), font=font) pil_im = pil_im.crop(pil_im.getbbox()) pil_im = ImageOps.invert(pil_im) #pil_im.save(str(n) + ".png") # convert to cv image cv_image = cv2.cvtColor(np.array(pil_im), cv2.COLOR_RGBA2BGRA) gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY) blur = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.adaptiveThreshold(blur, 255, 1, 1, 11, 2) roi = cv2.resize(thresh, (digitheight, digitheight / 2)) responses.append(n) sample = roi.reshape((1, digitheight * (digitheight / 2))) samples = np.append(samples, sample, 0) samples = np.array(samples, np.float32) responses = np.array(responses, np.float32) model = cv2.KNearest() model.train(samples, responses) return model
def __init__(self, character_width=15, character_height=15, classifier_type="svm_linear"): self.character_width = character_width self.character_height = character_height self.classifier_type = classifier_type self.resize = 128 if classifier_type == "knn": self.classifier = cv2.KNearest() else: self.classifier = cv2.SVM() if self.classifier_type == "svm_linear_hog": winSize = (128,128) blockSize = (32,32) blockStride = (16,16) cellSize = (8,8) nbins = 9 derivAperture = 1 winSigma = 4. histogramNormType = 0 L2HysThreshold = 2.0000000000000001e-01 gammaCorrection = 0 nlevels = 32 self.hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins,derivAperture,winSigma, histogramNormType,L2HysThreshold,gammaCorrection,nlevels)
def clusterize_colors(self, img, imgName): """Reduce colors by clusterizing the colors using K-Nearest algorithm. """ if img is None: return # Set the color classes colors = np.array( [[0x00, 0x00, 0x00], [0xff, 0xff, 0xff], [0xff, 0x00, 0xff]], dtype=np.float32) classes = np.array([[0], [1], [2]], np.float32) # Predict with K-Nearest knn = cv2.KNearest() knn.train(colors, classes) img_flatten = np.reshape(np.ravel(img, 'C'), (-1, 3)) retval, result, neighbors, dist = knn.find_nearest( img_flatten.astype(np.float32), 1) # Set new colors dst = colors[np.ravel(result, 'C').astype(np.uint8)] dst = dst.reshape(img.shape).astype(np.uint8) # Save image if self.debug: cv2.imwrite(imgName, dst) return dst
def recognize(thresh, AireContourMini, hmin, factor=1): digits = [] #Entrainement de kNN à partir de deux fichiers samples = np.loadtxt('samples.data', np.float32) responses = np.loadtxt('responses.data', np.float32) responses = responses.reshape((responses.size, 1)) model = cv2.KNearest() model.train(samples, responses) #Application contours, hierarchy = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: if cv2.contourArea(cnt) > AireContourMini: [x, y, w, h] = cv2.boundingRect(cnt) if h > hmin: roi = thresh[y:y + h, x:x + w] roismall = cv2.resize(roi, (10, 10)) roismall = roismall.reshape((1, 100)) roismall = np.float32(roismall) retval, results, neigh_resp, dists = model.find_nearest( roismall, k=factor) string = str(int((results[0][0]))) digits.append(string) cv2.waitKey(0) return digits pass
def icp(d1, d2, max_iterate=100): src = np.array([d1.T], copy=True).astype(np.float32) dst = np.array([d2.T], copy=True).astype(np.float32) knn = cv2.KNearest() responses = np.array(range(len(d2[0]))).astype(np.float32) knn.train(src[0], responses) Tr = np.array([[np.cos(0), -np.sin(0), 0], [np.sin(0), np.cos(0), 0], [0, 0, 1]]) dst = cv2.transform(dst, Tr[0:2]) max_dist = sys.maxint scale_x = np.max(d1[0]) - np.min(d1[0]) scale_y = np.max(d1[1]) - np.min(d1[1]) scale = max(scale_x, scale_y) for i in range(max_iterate): ret, results, neighbours, dist = knn.find_nearest(dst[0], 1) indeces = results.astype(np.int32).T indeces = del_miss(indeces, dist, max_dist) T = cv2.estimateRigidTransform(dst[0, indeces], src[0, indeces], True) max_dist = np.max(dist) dst = cv2.transform(dst, T) Tr = np.dot(np.vstack((T, [0, 0, 1])), Tr) if (is_converge(T, scale)): break return Tr[0:2]
def __init__(self, k=1, debug=False): if get_opencv_version() == 3: self.knn = cv2.ml.KNearest_create() else: self.knn = cv2.KNearest() self.k = k self.debug = debug
def create_model(self, train_folder): """ Return the training set, its labels and the trained model :param train_folder: folder where to retrieve data :return: (train_set, train_labels, trained_model) """ digits = [] labels = [] for n in range(1, 10): folder = train_folder + str(n) samples = [pic for pic in os.listdir(folder) if os.path.isfile(os.path.join(folder, pic))] for sample in samples: image = cv2.imread(os.path.join(folder, sample)) # Expecting black on white image = 255 - cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) _, image = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) feat = self.feature(image) digits.append(feat) labels.append(n) digits = np.array(digits, np.float32) labels = np.array(labels, np.float32) if cv2.__version__[0] == '2': model = cv2.KNearest() model.train(digits, labels) else: model = cv2.ml.KNearest_create() model.train(digits, cv2.ml.ROW_SAMPLE, labels) return digits, labels, model
def __init__(self, saved_model=None, train_folder=None, feature=_feature.__func__): """ :param saved_model: optional saved train set and labels as .npz :param train_folder: optional custom train data to process :param feature: feature function - compatible with saved_model """ self.feature = feature if train_folder is not None: self.train_set, self.train_labels, self.model = \ self.create_model(train_folder) else: if cv2.__version__[0] == '2': self.model = cv2.KNearest() else: self.model = cv2.ml.KNearest_create() if saved_model is None: saved_model = TRAIN_DATA+'raw_pixel_data.npz' with np.load(saved_model) as data: self.train_set = data['train_set'] self.train_labels = data['train_labels'] if cv2.__version__[0] == '2': self.model.train(self.train_set, self.train_labels) else: self.model.train(self.train_set, cv2.ml.ROW_SAMPLE, self.train_labels)
def teamMain(): DIR = '/home/archer/Documents/maxent/data/basketball/leaguerank/' teamIds = loadTeamIds(DIR + 'teamidshortname.csv') teamNames = [x[1] for x in loadMatrixFromFile(DIR + 'teamidshortname.csv')] countTotal = 0 total = 0 for team in teamIds: trainData = buildTrainingSets(DIR + team + '-train.csv') trainLabels = buildTrainingLabels(DIR + team + '-train.csv') testData = buildTestingSets(DIR + team + '-test.csv') testLabels = buildTestingLabels(DIR + team + '-test.csv') total = total + len(testLabels) knn = cv2.KNearest() knn.train(trainData, trainLabels) # Accuracy count = 0 for i in range(len(testLabels)): ret, results, neighbours, dist = knn.find_nearest( np.array([testData[i]]), 11) if results[0][0] == testLabels[i][0]: count = count + 1 countTotal = countTotal + count print 'INFO: Accuracy(', teamNames[teamIds.index( team)], ')', count / float(len(testLabels)) print 'INFO: Total Accuracy: ', countTotal / float(total)
def seasonMain(): DIR = '/home/archer/Documents/maxent/data/basketball/leaguerank/' seasons = loadSeasons(DIR + 'seasons-18-Nov-2014.txt') countTotal = 0 total = 0 for season in seasons: trainData = buildTrainingSets(DIR + season + '-train.csv') testData = buildTestingSets(DIR + season + '-test.csv') trainLabels = buildTestingLabels(DIR + season + '-train.csv') testLabels = buildTestingLabels(DIR + season + '-test.csv') total = total + len(testLabels) knn = cv2.KNearest() knn.train(trainData, trainLabels) # Accuracy count = 0 for i in range(len(testLabels)): ret, results, neighbours, dist = knn.find_nearest( np.array([testData[i]]), 11) if results[0][0] == testLabels[i][0]: count = count + 1 countTotal = countTotal + count print 'INFO: Accuracy(', season, ')', count / float(len(testLabels)) print 'INFO: Total Accuracy: ', countTotal / float(total)
def __init__(self): self.knn = cv2.KNearest() self.results = [] self.a = 10.0 #KNN can't train on letters so a = 10 and m = 11 self.m = 11.0 self.mnist_labels = [] self.mnist_data = [] return
def train_from_file(self, train_data_file): train = np.load(train_data_file + "/train_captchas_data_images.npy") train_labels = np.load(train_data_file + "/train_captchas_data_labels.npy") knn = cv2.KNearest() knn.train(train, train_labels) return knn
def __init__(self, className): """ Note: Set Settings.K_NUMBER_OF_NEIGHBORS_K for the variable k before calling this constructor. """ super(KNearestNeighbours, self).__init__(ModelType.KNearest, True) self.className = className self.__model = cv.KNearest() self.k = Settings.K_NUMBER_OF_NEIGHBORS_K