def rotate_bdd(X_train, deg): HOG_train = np.zeros((len(X_train), 324)) for i in range(len(X_train)): image = X_train.ix[i].values.reshape(3, 32, 32).transpose(1, 2, 0) im = rotate(image, deg) HOG_train[i, :] = hog(im) return HOG_train
def flip_bdd(X_train): HOG_train = np.zeros((len(X_train), 324)) for i in range(len(X_train)): image = X_train.ix[i].values.reshape(3, 32, 32).transpose(1, 2, 0) im = flip(image, 1) HOG_train[i, :] = hog(im) return HOG_train
def fit(self, X, y, pix=False): ''' Fit model to the observation (X,y) of detection ''' y = np.array(y) X_feat = [] AR = [[] for i in range(self.K)] for i, im in enumerate(X): ai = im.size[0] * 1. / im.size[1] if y[i] < self.K: AR[y[i]].append(ai) im_r = im.resize((22, 20)) if not pix: X_feat.append(hog(im_r, 4).reshape((-1, ))) else: im_r = im_r.convert('L') im_a = np.array(im_r.getdata()).reshape((-1, )) X_feat.append(im_a) for i in range(self.K): y_feat = (y == i) self.model[i].fit(X_feat, y_feat) self.AR = np.array([[np.mean(AR[i]), np.var(AR[i])] for i in range(self.K)])
def fit(self, X, y, pix=False): ''' Fit model to the observation (X,y) of detection ''' y = np.array(y) X_feat = [] AR = [[] for i in range(self.K)] for i, im in enumerate(X): ai = im.size[0]*1./im.size[1] if y[i] < self.K: AR[y[i]].append(ai) im_r = im.resize((22,20)) if not pix: X_feat.append(hog(im_r,4).reshape((-1,))) else: im_r = im_r.convert('L') im_a = np.array(im_r.getdata()).reshape((-1,)) X_feat.append(im_a) for i in range(self.K): y_feat = (y==i) self.model[i].fit(X_feat, y_feat) self.AR = np.array([[np.mean(AR[i]),np.var(AR[i])] for i in range(self.K)])
def detect(gray, frame, model): faces = face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2) #label = model.predict(lbp_hist(gray[y:y+h, x:x+w] ,25,8).reshape(1,-1)) label = model.predict(hog(cv2.resize(gray[y:y+h, x:x+w], (150,150))).reshape(1,-1)) cv2.putText(frame, label[0], (x+w,y-5), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,0), 2, cv2.LINE_AA) #print(label) return frame
def detection(self, im, th, th1=0.1, pix=False): ''' Perform the sliding window detection on im return a list with (x, y, class, proba) ''' w = self.width h = self.height a = w * 1. / h w0 = im.size[0] - w h0 = im.size[1] - h res = [] Ntot = w0 * h0 for i in range(w0): for j in range(h0): sys.stdout.write('\rChar detect...{:6.2%}'.format( (i * h0 + j) * 1. / Ntot)) sys.stdout.flush() X = im.crop((i, j, i + w, j + h)) X_r = X.resize((22, 20)) X_feat = [] if not pix: X_feat.append(hog(X_r, 4).reshape((-1, ))) else: im_r = im_r.convert('L') im_a = np.array(X_r.getdata()).reshape((-1, )) X_feat.append(im_a) p = [] for k in range(self.K): p.append(self.model[k].predict_proba(X_feat)[0, 1]) cj = np.argmax(p) muj, sigj = self.AR[cj] GS = p[cj] * np.exp(-(muj - a)**2 / (2 * sigj)) if GS > th1: res.append((i, j, p, cj, p[cj], GS)) print '\rChar detect...done ' return self.NMS(res, th)
def detection(self, im, th, th1=0.1, pix=False): ''' Perform the sliding window detection on im return a list with (x, y, class, proba) ''' w = self.width h = self.height a = w*1./h w0 = im.size[0] - w h0 = im.size[1] - h res = [] Ntot = w0*h0 for i in range(w0): for j in range(h0): sys.stdout.write('\rChar detect...{:6.2%}'.format( (i*h0+j)*1./Ntot)) sys.stdout.flush() X = im.crop((i,j,i+w,j+h)) X_r = X.resize((22,20)) X_feat = [] if not pix: X_feat.append(hog(X_r,4).reshape((-1,))) else: im_r = im_r.convert('L') im_a = np.array(X_r.getdata()).reshape((-1,)) X_feat.append(im_a) p = [] for k in range(self.K): p.append(self.model[k].predict_proba(X_feat)[0,1]) cj = np.argmax(p) muj,sigj = self.AR[cj] GS = p[cj]*np.exp(-(muj-a)**2/(2*sigj)) if GS > th1: res.append((i,j,p, cj, p[cj], GS)) print '\rChar detect...done ' return self.NMS(res, th)
def test(self, X, y, pix=False): ''' Test model on the observation (X,y) ''' y = np.array(y) X_feat = [] AR = [] for i, im in enumerate(X): ai = im.size[0] * 1. / im.size[1] AR.append(ai) im_r = im.resize((22, 20)) if not pix: X_feat.append(hog(im_r, 4).reshape((-1, ))) else: im_r = im_r.convert('L') im_a = np.array(im_r.getdata()).reshape((-1, )) X_feat.append(im_a) p = [] for k in range(self.K): p.append(self.model[k].predict_proba(X_feat)[:, 1]) p = np.array(p) i0 = p.argmax(axis=0) AR = np.array(AR) detect = np.exp(-(self.AR[i0, 0] - AR[i0])**2 / (2 * self.AR[i0, 1])) GS = np.multiply(p[i0, range(y.shape[0])], detect) err2 = ((y - i0).nonzero()[0].shape[0]) * 1. / y.shape[0] err = 1 - (GS > 0.1).mean() print('\nThis model miss {:6.2%} of the' ' character in the test db').format(err) print( 'This model failed to recognize {:6.2%} character ' 'of the test db').format(err2)
def test(self, X, y, pix=False): ''' Test model on the observation (X,y) ''' y = np.array(y) X_feat = [] AR = [] for i, im in enumerate(X): ai = im.size[0]*1./im.size[1] AR.append(ai) im_r = im.resize((22,20)) if not pix: X_feat.append(hog(im_r,4).reshape((-1,))) else: im_r = im_r.convert('L') im_a = np.array(im_r.getdata()).reshape((-1,)) X_feat.append(im_a) p = [] for k in range(self.K): p.append(self.model[k].predict_proba(X_feat)[:,1]) p = np.array(p) i0 = p.argmax(axis=0) AR = np.array(AR) detect = np.exp(-(self.AR[i0,0]-AR[i0])**2/(2*self.AR[i0,1])) GS = np.multiply(p[i0, range(y.shape[0])], detect) err2 = ((y-i0).nonzero()[0].shape[0])*1./y.shape[0] err = 1- (GS>0.1).mean() print ('\nThis model miss {:6.2%} of the' ' character in the test db').format(err) print ('This model failed to recognize {:6.2%} character ' 'of the test db').format(err2)
import features import cv2 import numpy as np import matplotlib.pyplot as plt im1 = cv2.imread('output/000045.png') template = cv2.imread('output/template.png') template = cv2.cvtColor(template, cv2.COLOR_BGR2RGB) im1 = im1[im1.shape[0] - 720:, im1.shape[1] - 720:, :] template = template[50:350, 50:350, :] print(template.shape, im1.shape) tmp = features.hog(template) img = features.hog(im1) print(img.shape, tmp.shape) r, c, _ = tmp.shape sse = np.zeros(img.shape[:2]) # print for i in range(img.shape[0] - r): for j in range(img.shape[1] - c): sse[i, j] = np.sqrt( np.square(img[i:i + r, j:j + c, :] - tmp).sum(axis=(0, 1))).sum() tgt = np.argmin(sse[:img.shape[0] - r, :img.shape[1] - c]) match = np.unravel_index(tgt, (img.shape[0] - r, img.shape[1] - c)) print(match) a = plt.figure() ax = a.add_subplot(121)
print(result_CV) print("Groundtruth: ") print(Yval) precision = np.sum(Yval == result_CV) / len(result_CV) print("Precision: %f" % precision) print("Time: ", time.time() - temps) print('____________________') # Compute HOG vector on testing set HOG_test = np.zeros((len(X_test), 324)) for i in range(len(X_test)): im = X_test.ix[i].values.reshape(3, 32, 32).transpose(1, 2, 0) # imGray = rgb2gray(im) # HOG_test[i, :] = hog(imGray, cells_per_block=(2,2)) HOG_test[i, :] = hog(im) Xtrain = HOG_train Ytrain = Y_train['Prediction'].as_matrix() Xtest = HOG_test print("Fitting") parameters = one_vs_all(Xtrain, Ytrain, C, kernel) print('____________________') print("Predicting") temps = time.time() number_of_classes = len(np.unique(Ytrain)) result = predict_multiclass(Xtest, number_of_classes, parameters)
backgrounds = [] for k, frame in enumerate(frames[0:100:10]): im = frame[:360].astype('double') / 255.0 #im = skimage.color.rgb2hsv((im * 255).astype('uint8')) #plt.imshow(im[:, :, 0], interpolation = 'NONE', cmap = plt.cm.hsv); #plt.colorbar() #plt.show() #plt.imshow(im[:, :, 1], interpolation = 'NONE', cmap = plt.cm.hsv); #plt.colorbar() #plt.show() #plt.imshow(im[:, :, 2], interpolation = 'NONE', cmap = plt.cm.hsv); #plt.colorbar() #plt.show() tmp = time.time() hog = features.hogpad(features.hog(im, b)) rgb = features.rgbhist(im, b) print time.time() - tmp #plt.imshow(im, interpolation = 'NONE') #plt.show() #plt.imshow(skimage.color.rgb2gray(im), interpolation = 'NONE', cmap = plt.cm.gray) #plt.imshow(rgb, interpolation = 'NONE') #plt.show() Y = rgb.shape[0] X = rgb.shape[1] rgbf = numpy.zeros((rgb.shape[0], rgb.shape[1], sy * sx * rgb.shape[2])) indices[k] = []
def hog(self, mode='dense', algorithm='dalaltriggs', num_bins=9, cell_size=8, block_size=2, signed_gradient=True, l2_norm_clip=0.2, window_height=1, window_width=1, window_unit='blocks', window_step_vertical=1, window_step_horizontal=1, window_step_unit='pixels', padding=True, verbose=False, constrain_landmarks=True): r""" Represents a 2-dimensional HOG features image with C number of channels. The output object's class is either MaskedImage or Image depending on the input image. Parameters ---------- mode : 'dense' or 'sparse' The 'sparse' case refers to the traditional usage of HOGs, so default parameters values are passed to the ImageWindowIterator. The sparse case of 'dalaltriggs' algorithm sets the window height and width equal to block size and the window step horizontal and vertical equal to cell size. Thse sparse case of 'zhuramanan' algorithm sets the window height and width equal to 3 times the cell size and the window step horizontal and vertical equal to cell size. In the 'dense' case, the user can change the ImageWindowIterator related parameters (window_height, window_width, window_unit, window_step_vertical, window_step_horizontal, window_step_unit, padding). Default: 'dense' window_height : float Defines the height of the window for the ImageWindowIterator object. The metric unit is defined by window_unit. Default: 1 window_width : float Defines the width of the window for the ImageWindowIterator object. The metric unit is defined by window_unit. Default: 1 window_unit : 'blocks' or 'pixels' Defines the metric unit of the window_height and window_width parameters for the ImageWindowIterator object. Default: 'blocks' window_step_vertical : float Defines the vertical step by which the window in the ImageWindowIterator is moved, thus it controls the features density. The metric unit is defined by window_step_unit. Default: 1 window_step_horizontal : float Defines the horizontal step by which the window in the ImageWindowIterator is moved, thus it controls the features density. The metric unit is defined by window_step_unit. Default: 1 window_step_unit : 'pixels' or 'cells' Defines the metric unit of the window_step_vertical and window_step_horizontal parameters for the ImageWindowIterator object. Default: 'pixels' padding : bool Enables/disables padding for the close-to-boundary windows in the ImageWindowIterator object. When padding is enabled, the out-of-boundary pixels are set to zero. Default: True algorithm : 'dalaltriggs' or 'zhuramanan' Specifies the algorithm used to compute HOGs. Default: 'dalaltriggs' cell_size : float Defines the cell size in pixels. This value is set to both the width and height of the cell. This option is valid for both algorithms. Default: 8 block_size : float Defines the block size in cells. This value is set to both the width and height of the block. This option is valid only for the 'dalaltriggs' algorithm. Default: 2 num_bins : float Defines the number of orientation histogram bins. This option is valid only for the 'dalaltriggs' algorithm. Default: 9 signed_gradient : bool Flag that defines whether we use signed or unsigned gradient angles. This option is valid only for the 'dalaltriggs' algorithm. Default: True l2_norm_clip : float Defines the clipping value of the gradients' L2-norm. This option is valid only for the 'dalaltriggs' algorithm. Default: 0.2 constrain_landmarks : bool Flag that if enabled, it constrains landmarks that ended up outside of the features image bounds. Default: True verbose : bool Flag to print HOG related information. Default: False Raises ------- ValueError HOG features mode must be either dense or sparse ValueError Algorithm must be either dalaltriggs or zhuramanan ValueError Number of orientation bins must be > 0 ValueError Cell size (in pixels) must be > 0 ValueError Block size (in cells) must be > 0 ValueError Value for L2-norm clipping must be > 0.0 ValueError Window height must be >= block size and <= image height ValueError Window width must be >= block size and <= image width ValueError Window unit must be either pixels or blocks ValueError Horizontal window step must be > 0 ValueError Vertical window step must be > 0 ValueError Window step unit must be either pixels or cells """ # compute hog features and windows_centres hog, window_centres = fc.hog(self._image.pixels, mode=mode, algorithm=algorithm, cell_size=cell_size, block_size=block_size, num_bins=num_bins, signed_gradient=signed_gradient, l2_norm_clip=l2_norm_clip, window_height=window_height, window_width=window_width, window_unit=window_unit, window_step_vertical=window_step_vertical, window_step_horizontal= window_step_horizontal, window_step_unit=window_step_unit, padding=padding, verbose=verbose) # create hog image object hog_image = self._init_feature_image(hog, window_centres=window_centres, constrain_landmarks= constrain_landmarks) # store parameters hog_image.hog_parameters = {'mode': mode, 'algorithm': algorithm, 'num_bins': num_bins, 'cell_size': cell_size, 'block_size': block_size, 'signed_gradient': signed_gradient, 'l2_norm_clip': l2_norm_clip, 'window_height': window_height, 'window_width': window_width, 'window_unit': window_unit, 'window_step_vertical': window_step_vertical, 'window_step_horizontal': window_step_horizontal, 'window_step_unit': window_step_unit, 'padding': padding, 'original_image_height': self._image.pixels.shape[0], 'original_image_width': self._image.pixels.shape[1], 'original_image_channels': self._image.pixels.shape[2]} return hog_image
# loop over the images in each sub-folder for file in images: # get the image file name file_path = os.path.join(current_dir, file) # read the image and resize it to a fixed-size image = cv2.imread(file_path) image = cv2.resize(image, fixed_size) #################################### # Global Feature extraction #################################### fv_histogram = fd_haralick(image) fv_kaze = kaze_func(image) fv_hog = hog(image) fv_fast = fd_Fast(image) fv_lin = lin(image) fv_ORB = fd_ORB(image) #fv_hu_moments = fd_hu_moments(image) # #fv_4 = fd_4(image) ################################### # Concatenate global features ################################### global_feature = np.hstack([fv_histogram, fv_kaze]) # update the list of labels and feature vectors labels.append(current_label) global_features.append(global_feature) print("[STATUS] processed folder: {}".format(current_label))
#label = model.predict(lbp_hist(gray[y:y+h, x:x+w] ,25,8).reshape(1,-1)) label = model.predict(hog(cv2.resize(gray[y:y+h, x:x+w], (150,150))).reshape(1,-1)) cv2.putText(frame, label[0], (x+w,y-5), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,0), 2, cv2.LINE_AA) #print(label) return frame if args['train'] is not None: path = args["train"] data_paths = [os.path.join(r, n) for r, _, f in os.walk(path) for n in f] #data = np.asarray([lbp_hist(i ,25,8) for i in tqdm(data_paths)]) data = np.asarray([hog(i) for i in tqdm(data_paths)]) labels = np.asarray([i.split('\\')[1] for i in tqdm(data_paths)]) pkl.dump([data,labels], open('/data_array_hog.pkl', 'wb')) # data, labels = pkl.load(open('/data_array.pkl', 'rb')) arr = np.random.permutation(len(labels)) data = data[arr] labels = labels[arr] scaler = StandardScaler() scaler.fit(data) #scaler.transform(data) x_train, x_test, y_train, y_test = train_test_split(data, labels, train_size = 0.7, random_state = 42)