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
