def findFaces(self, img): faces = [] self.detect_time = time.time() rects = self.face_detector.detect(img) self.detect_time = time.time() - self.detect_time cvtile = opencv.cvCreateMat(128, 128, opencv.CV_8UC3) bwtile = opencv.cvCreateMat(128, 128, opencv.CV_8U) cvimg = img.asOpenCV() self.eye_time = time.time() for rect in rects: faceim = opencv.cvGetSubRect(cvimg, rect.asOpenCV()) opencv.cvResize(faceim, cvtile) affine = pv.AffineFromRect(rect, (128, 128)) opencv.cvCvtColor(cvtile, bwtile, cv.CV_BGR2GRAY) leye, reye, lcp, rcp = self.fel.locateEyes(bwtile) leye = pv.Point(leye) reye = pv.Point(reye) leye = affine.invertPoint(leye) reye = affine.invertPoint(reye) faces.append([rect, leye, reye]) self.eye_time = time.time() - self.eye_time self.current_faces = faces return faces
def emd(prediction, ground_truth): """ Compute the Eart Movers Distance between prediction and model. This implementation uses opencv for doing the actual work. Unfortunately, at the time of implementation only the SWIG bindings werer available and the numpy arrays have to converted by hand. This changes with opencv 2.1. """ import opencv if not (prediction.shape == ground_truth.shape): raise RuntimeError('Shapes of prediction and ground truth have' + ' to be equal. They are: %s, %s' %(str(prediction.shape), str(ground_truth.shape))) (x, y) = np.meshgrid(range(0, prediction.shape[1]), range(0, prediction.shape[0])) s1 = np.array([x.flatten(), y.flatten(), prediction.flatten()]).T s2 = np.array([x.flatten(), y.flatten(), ground_truth.flatten()]).T s1m = opencv.cvCreateMat(s1.shape[0], s2.shape[1], opencv.CV_32FC1) s2m = opencv.cvCreateMat(s1.shape[0], s2.shape[1], opencv.CV_32FC1) for r in range(0, s1.shape[0]): for c in range(0, s1.shape[1]): s1m[r, c] = float(s1[r, c]) s2m[r, c] = float(s2[r, c]) d = opencv.cvCalcEMD2(s1m, s2m, opencv.CV_DIST_L2) return d
def PerspectiveFromPoints(source, dest, new_size, method=0, ransacReprojThreshold=1.5): ''' Calls the OpenCV function: cvFindHomography. This method has additional options to use the CV_RANSAC or CV_LMEDS methods to find a robust homography. Method=0 appears to be similar to PerspectiveFromPoints. ''' assert len(source) == len(dest) n_points = len(source) s = cv.cvCreateMat(n_points,2,cv.CV_32F) d = cv.cvCreateMat(n_points,2,cv.CV_32F) p = cv.cvCreateMat(3,3,cv.CV_32F) for i in range(n_points): s[i,0] = source[i].X() s[i,1] = source[i].Y() d[i,0] = dest[i].X() d[i,1] = dest[i].Y() results = cv.cvFindHomography(s,d,p,method,ransacReprojThreshold) matrix = pv.OpenCVToNumpy(p) return PerspectiveTransform(matrix,new_size)
def __init__(self, calibration_image_size, focal_length_pixels, optical_center_pixels, lens_distortion_radial): ''' Format for parameters: focal_length_pixels = (720.511045, 724.498871), optical_center_pixels = (324.277843, 236.260833), lens_distortion_radial = (-0.428665, 0.300025, -0.230655), ''' self.calibration_image_size = calibration_image_size self.focal_length_pixels = focal_length_pixels self.optical_center_pixels = optical_center_pixels self.lens_distortion_radial = lens_distortion_radial self.intrinsic_mat = np.array([[focal_length_pixels[0], 0, optical_center_pixels[0]], [0, focal_length_pixels[1], optical_center_pixels[1]], [0, 0, 1]]) self.inv_intrinsic_mat = np.linalg.inv(np.matrix(self.intrinsic_mat)) self.intrinsic_mat_cv = ut.numpymat2cvmat(self.intrinsic_mat) self.inv_intrinsic_mat_cv = ut.numpymat2cvmat(self.inv_intrinsic_mat) self.lens_distortion_radial_cv = cv.cvCreateMat(4, 1, cv.CV_32FC1) self.lens_distortion_radial_cv[0,0] = lens_distortion_radial[0] self.lens_distortion_radial_cv[1,0] = lens_distortion_radial[1] self.lens_distortion_radial_cv[2,0] = 0 #self.lens_distortion_radial_cv[2,0] = lens_distortion_radial[2] self.lens_distortion_radial_cv[3,0] = 0 self.temp = None self.mapx = cv.cvCreateMat(int(calibration_image_size[1]), int(calibration_image_size[0]), cv.CV_32FC1) self.mapy = cv.cvCreateMat(int(calibration_image_size[1]), int(calibration_image_size[0]), cv.CV_32FC1) cv.cvInitUndistortMap(self.intrinsic_mat_cv, self.lens_distortion_radial_cv, self.mapx, self.mapy)
def __init__(self, calibration_image_size, focal_length_pixels, optical_center_pixels, lens_distortion_radial): ''' Format for parameters: focal_length_pixels = (720.511045, 724.498871), optical_center_pixels = (324.277843, 236.260833), lens_distortion_radial = (-0.428665, 0.300025, -0.230655), ''' self.calibration_image_size = calibration_image_size self.focal_length_pixels = focal_length_pixels self.optical_center_pixels = optical_center_pixels self.lens_distortion_radial = lens_distortion_radial self.intrinsic_mat = np.array( [[focal_length_pixels[0], 0, optical_center_pixels[0]], [0, focal_length_pixels[1], optical_center_pixels[1]], [0, 0, 1]]) self.inv_intrinsic_mat = np.linalg.inv(np.matrix(self.intrinsic_mat)) self.intrinsic_mat_cv = ut.numpymat2cvmat(self.intrinsic_mat) self.inv_intrinsic_mat_cv = ut.numpymat2cvmat(self.inv_intrinsic_mat) self.lens_distortion_radial_cv = cv.cvCreateMat(4, 1, cv.CV_32FC1) self.lens_distortion_radial_cv[0, 0] = lens_distortion_radial[0] self.lens_distortion_radial_cv[1, 0] = lens_distortion_radial[1] self.lens_distortion_radial_cv[2, 0] = 0 #self.lens_distortion_radial_cv[2,0] = lens_distortion_radial[2] self.lens_distortion_radial_cv[3, 0] = 0 self.temp = None self.mapx = cv.cvCreateMat(int(calibration_image_size[1]), int(calibration_image_size[0]), cv.CV_32FC1) self.mapy = cv.cvCreateMat(int(calibration_image_size[1]), int(calibration_image_size[0]), cv.CV_32FC1) cv.cvInitUndistortMap(self.intrinsic_mat_cv, self.lens_distortion_radial_cv, self.mapx, self.mapy)
def setAffineTransform(self, i_center, i_scale, i_rot_angle): """See open cv documentation of cvWarpAffine""" if (abs(i_scale - 1.0) < 1E-6) and ( abs(i_rot_angle) < 1E-6 ): self.__rot_mat = None else: self.__rot_mat = cv.cvCreateMat(2,3, 5) #Affine matrix cv.cv2DRotationMatrix( i_center, i_rot_angle, i_scale, self.__rot_mat )
def setAffineTransform(self, i_center, i_scale, i_rot_angle): """See open cv documentation of cvWarpAffine""" if (abs(i_scale - 1.0) < 1E-6) and (abs(i_rot_angle) < 1E-6): self.__rot_mat = None else: self.__rot_mat = cv.cvCreateMat(2, 3, 5) #Affine matrix cv.cv2DRotationMatrix(i_center, i_rot_angle, i_scale, self.__rot_mat)
def test(self, feature_data = None): #test on current scan: print getTime(), 'test on:', self.processor.scan_dataset.id if feature_data == None: filename = self.processor.get_features_filename() print 'loading', filename dict = ut.load_pickle(filename) else: dict = feature_data #print getTime(), dict current_set_size = dict['set_size'] feature_vector_length = len(self.processor.features.get_indexvector(self.features)) print getTime(), feature_vector_length labels = np.array(np.zeros(len(self.processor.map_polys))) print 'test: length of labels vector:', len(labels) test = cv.cvCreateMat(1,feature_vector_length,cv.CV_32FC1) if current_set_size == 0: print getTime(), 'ERROR: test dataset is empty!' return labels, 1, 1, 1 count = 0 for index in dict['point_indices']: fv = (dict['features'][count])[self.processor.features.get_indexvector(self.features)] #print getTime(), fv, dict['features'][count] for fv_index, fv_value in enumerate(fv): test[fv_index] = fv_value #print 'class',self.cv_classifier label = self.cv_classifier.predict(test) #print label.value labels[index] = label.value #print 'tdone' if count % 4096 == 0: print getTime(), 'testing:', count, 'of', current_set_size, '(',(float(count)/float(current_set_size)*100.0),'%)' count += 1 #save for later use for postprocessing: self.test_feature_dict = dict self.test_labels = labels #cv.cvReleaseMat(test) return labels, self.test_results(dict, labels)
def create_train_datastructures(self): #loop through all marked datasets self.processor.scan_dataset = self.processor.scans_database.get_dataset(0) training_set_size = 0 data = [] #get size of training set in total while False != self.processor.scan_dataset: if self.processor.scan_dataset.is_training_set: filename = self.processor.get_features_filename(True) print 'loading', filename dict = ut.load_pickle(filename) # make an equal size of points for each class: use object labels more often: difference = np.sum(dict['labels'] == processor.LABEL_SURFACE) - np.sum(dict['labels'] == processor.LABEL_CLUTTER) #print getTime(), filename #print getTime(), 'surface',np.sum(dict['labels'] == LABEL_SURFACE) #print getTime(), 'clutter',np.sum(dict['labels'] == LABEL_CLUTTER) #print getTime(), difference, "difference = np.sum(dict['labels'] == LABEL_SURFACE) - np.sum(dict['labels'] == LABEL_CLUTTER)" #print getTime(), '' if difference > 0: clutter_features = (dict['features'])[np.nonzero(dict['labels'] == processor.LABEL_CLUTTER)] if len(clutter_features) > 0: #if there are none, do nothin' dict['set_size'] += difference dict['features'] = np.vstack((dict['features'], clutter_features[np.random.randint(0,len(clutter_features),size=difference)])) dict['labels'] = np.hstack((dict['labels'], np.ones(difference) * processor.LABEL_CLUTTER)) elif difference < 0: surface_features = (dict['features'])[np.nonzero(dict['labels'] == processor.LABEL_SURFACE)] if len(surface_features) > 0: #if there are none, do nothin' difference = -difference dict['set_size'] += difference dict['features'] = np.vstack((dict['features'], surface_features[np.random.randint(0,len(surface_features),size=difference)])) dict['labels'] = np.hstack((dict['labels'], np.ones(difference) * processor.LABEL_SURFACE)) training_set_size += dict['set_size'] data.append(dict) #get next one self.processor.scan_dataset = self.processor.scans_database.get_next_dataset() #print getTime(), self.scan_dataset #create training set: self.processor.scan_dataset = self.processor.scans_database.get_dataset(0) current_training_set_index = 0 feature_vector_length = len(self.processor.features.get_indexvector(self.features)) print getTime(), feature_vector_length #create dataset matrices: print getTime(), '#training set size ', training_set_size #deactivate for now: max_traning_size = 1800000#2040000 #if training_set_size < max_traning_size: if True: train_data = cv.cvCreateMat(training_set_size,feature_vector_length,cv.CV_32FC1) #CvMat* cvCreateMat(int rows, int cols, int type) train_labels = cv.cvCreateMat(training_set_size,1,cv.CV_32FC1) for dict in data: for index in range(dict['set_size']): #only train on surface and clutter if dict['labels'][index] == processor.LABEL_SURFACE or dict['labels'][index]== processor.LABEL_CLUTTER: #print getTime(), point3d #print getTime(), 'fvindexv',self.get_features_indexvector(features) #print getTime(), 'len', len(self.get_features_indexvector(features)) fv = (dict['features'][index])[self.processor.features.get_indexvector(self.features)] #print getTime(), 'fv',fv #print getTime(), np.shape(fv) for fv_index, fv_value in enumerate(fv): train_data[current_training_set_index][fv_index] = fv_value train_labels[current_training_set_index] = dict['labels'][index] # for fv_index, fv_value in enumerate(fv): # print getTime(), train_data[current_training_set_index][fv_index] # print getTime(), '##',train_labels[current_training_set_index],'##' #print getTime(), 'fv ', fv #print getTime(), 'tr ',train_data[index] current_training_set_index = current_training_set_index + 1 #if current_training_set_index % 4096 == 0: # print getTime(), 'label', dict['labels'][index], 'fv', fv if current_training_set_index % 16384 == 0: print getTime(), 'reading features:', current_training_set_index, 'of', training_set_size, '(',(float(current_training_set_index)/float(training_set_size)*100.0),'%)' else: print getTime(), 'more than',max_traning_size,'features, sample from them...' #select 2040000 features: all_data = [] all_labels = [] for dict in data: for index in range(dict['set_size']): if dict['labels'][index] == processor.LABEL_SURFACE or dict['labels'][index]== processor.LABEL_CLUTTER: fv = (dict['features'][index])[self.processor.features.get_indexvector(self.features)] all_data += [fv] all_labels += [dict['labels'][index]] current_training_set_index = current_training_set_index + 1 if current_training_set_index % 16384 == 0: print getTime(), 'reading features:', current_training_set_index, 'of', training_set_size, '(',(float(current_training_set_index)/float(training_set_size)*100.0),'%)' del data import random indices = np.array(random.sample(xrange(len(all_labels)),max_traning_size)) all_data = np.asarray(all_data) all_labels = np.asarray(all_labels) all_data = all_data[indices] all_labels = all_labels[indices] train_data = cv.cvCreateMat(max_traning_size,feature_vector_length,cv.CV_32FC1) #CvMat* cvCreateMat(int rows, int cols, int type) train_labels = cv.cvCreateMat(max_traning_size,1,cv.CV_32FC1) for index in range(max_traning_size): for fv_index, fv_value in enumerate(all_data[index]): train_data[index][fv_index] = fv_value train_labels[index] = all_labels[index] if index % 16384 == 0: print getTime(), 'setting features:', (float(index)/float(max_traning_size)) print getTime(), 'start training Classifier' type_mask = cv.cvCreateMat(1, feature_vector_length+1, cv.CV_8UC1) cv.cvSet( type_mask, cv.CV_VAR_NUMERICAL, 0) type_mask[feature_vector_length] = cv.CV_VAR_CATEGORICAL return (train_data, train_labels, type_mask)
def rodrigues(vec): cvvec = ut.numpymat2cvmat(vec) dst = cv.cvCreateMat(3,3,cv.CV_32FC1) cv.cvRodrigues2(cvvec, dst) return ut.cvmat2numpymat(dst).T
def rodrigues(vec): cvvec = ut.numpymat2cvmat(vec) dst = cv.cvCreateMat(3, 3, cv.CV_32FC1) cv.cvRodrigues2(cvvec, dst) return ut.cvmat2numpymat(dst).T