def _worker_init_face_recognizer(self):
starttime = time.time()
face_recognizer = cv2.createLBPHFaceRecognizer()
faces_dir = self.get_faces_rootfolder()
logging.info("OpenCV._worker_init_face_recognizer() loading face-images from %s..." % (faces_dir,))
face_images = []
self._face_label2name = {-1: "*ingen*"}
face_labels = []
for face_label, (dirpath, dirnames, filenames) in enumerate(os.walk(faces_dir)):
name = os.path.basename(dirpath)
for filename in filenames:
if not filename.startswith(".") and ("_raw" in filename):
# The coordinates of the eyes are encoded in the image filename
timestamp, eye_left_x, eye_left_y, eye_right_x, eye_right_y = filename.split("_")[:5]
filepath = os.path.join(dirpath, filename)
normalized_face_filename = os.path.join(dirpath, "%s_normalized.tiff" % (timestamp,))
if os.path.exists(normalized_face_filename):
normalized_face = cv2.imread(normalized_face_filename, cv2.CV_LOAD_IMAGE_GRAYSCALE)
is_high_quality_image = True
else:
logging.info(
"No normalized version found for the raw image, so I'll create it now (raw image:%s)"
% (filepath,)
)
original_image = cv2.imread(filepath)
normalized_face, is_high_quality_image = self.normalize_faceimage(
original_image,
eye_left=(int(eye_left_x), int(eye_left_y)),
eye_right=(int(eye_right_x), int(eye_right_y)),
)
if is_high_quality_image:
cv2.imwrite(normalized_face_filename, normalized_face)
else:
logging.warn(
"OpenCV._worker_init_face_recognizer() didn't find a face in the file '%s'!"
% (filepath,)
)
# os.remove(filepath)
if is_high_quality_image:
face_images.append(normalized_face)
face_labels.append(face_label)
self._face_label2name[face_label] = name
face_labels = numpy.asarray(face_labels, dtype=numpy.int32)
face_images = numpy.asarray(face_images)
if len(face_images) > 0:
self.face_recognizer = cv2.createLBPHFaceRecognizer()
self.face_recognizer.train(face_images, face_labels)
else:
self.face_recognizer = None
elapsedtime = time.time() - starttime
logging.info(
"OpenCV._worker_init_face_recognizer() loaded %d images for %d labels in %.2f seconds"
% (len(face_images), len(self._face_label2name) - 1, elapsedtime)
)
def __init__(self):
self.X = []
self.y = []
self.path = "Faces"
self.recognizerPath = "LBPHFaceRecognizers/recognizer.re"
self.speechEngine = pyttsx.init()
try:
self.recognizer = cv2.createLBPHFaceRecognizer()
self.recognizer.load(self.recognizerPath)
except:
self.recognizer = cv2.createLBPHFaceRecognizer()
def __init__(self):
self.CascadePath = "assets/haarcascades/haarcascade_frontalface_alt.xml"
self.ClientPath = "db/PredictionDatabase.csv"
self.GenderPath = "db/GenderDatabase.csv"
self.TrainingDBPath = "db/TrainingDatabase.csv"
self.XML = "assets/face_trained.xml"
self.genderXML = "assets/gender_trained.xml"
self.ClientImage = ""
self.FaceCascade = cv2.CascadeClassifier(self.CascadePath)
self.Recognizer = cv2.createLBPHFaceRecognizer()
self.GenderRecognizer = cv2.createLBPHFaceRecognizer()
self.UserName = "******"
self.FLAG = 0 # Utility flag
def train(self,gallery):
for face in gallery:
img = [self.imgfun(face)]
label = np.array([face.person])
recognizer = cv2.createLBPHFaceRecognizer()
recognizer.train(img,label)
self.recognizers.append(recognizer)
def train_recognizers(base64_path, models_path, sample_size=10):
if not os.path.exists(models_path):
os.mkdir(models_path)
# faces = paths.list_files(base64_path, validExts=('.txt',))
# loop over the input faces for training
for (i, path) in enumerate(glob.glob(base64_path + "/*.txt")):
fr = FaceRecognizer(cv2.createLBPHFaceRecognizer(radius=1, neighbors=8, grid_x=8, grid_y=8))
# labels = []
# extract the person from the file name,
name = path[path.rfind("/") + 1:].replace(".txt", "")
print("[INFO] training on '{}'".format(name))
# load the faces file, sample it, and initialize the list of faces
sample = open(path).read().strip().split("\n")
sample = random.sample(sample, min(len(sample), sample_size))
faces = []
# loop over the faces in the sample
for face in sample:
# decode the face and update the list of faces
faces.append(encodings.base64_decode_image(face))
# train the face detector on the faces and update the list of labels
fr.train(faces, np.array([i] * len(faces)))
# labels = name
# update the face recognizer to include the face name labels, then write the model to file
fr.setLabels((name,))
model_path = os.path.join(models_path, name + '.model')
fr.save(model_path)
def run_training(training_data, identity, frames):
# For face detection we will use the Haar Cascade provided by OpenCV.
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
# For face recognition we will the the LBPH Face Recognizer
recognizer = cv2.createLBPHFaceRecognizer()
try:
recognizer.load(training_data)
except Exception:
pass
images, labels = [], []
for frame in frames:
# Convert the image format into numpy array
image = np.array(frame, 'uint8')
for (x, y, w, h) in faceCascade.detectMultiScale(image):
images.append(image[y: y + h, x: x + w])
labels.append(int(identity))
cv2.waitKey(1)
print len(images)
cv2.destroyAllWindows()
# Perform the training
recognizer.update(images, np.array(labels));
recognizer.save(training_data)
def cv_init(self):
self.bridge = CvBridge()
cascade_eye = "./model/haarcascades/haarcascade_eye.xml"
cascade_1 = rospy.get_param(
"~cascade_1", "./model/haarcascades/haarcascade_frontalface_alt2.xml")
cascade_2 = rospy.get_param(
"~cascade_2", "./model/haarcascades/haarcascade_frontalface_alt.xml")
cascade_3 = rospy.get_param(
"~cascade_3", "./model/haarcascades/haarcascade_frontalface_profileface.xml")
self.cascade_1 = cv2.CascadeClassifier(cascade_1)
self.cascade_2 = cv2.CascadeClassifier(cascade_2)
self.cascade_3 = cv2.CascadeClassifier(cascade_3)
self.cascade_eye = cv2.CascadeClassifier(cascade_eye)
self.haar_scaleFactor = rospy.get_param("~haar_scaleFactor", 1.3)
self.haar_minNeighbors = rospy.get_param("~haar_minNeighbors", 4)
self.haar_minSize = rospy.get_param("~haar_minSize", 30)
#self.haar_maxSize = rospy.get_param("~haar_maxSize", 150)
self.haar_params = dict(scaleFactor=self.haar_scaleFactor,
minNeighbors=self.haar_minNeighbors,
flags=cv.CV_HAAR_DO_CANNY_PRUNING,
minSize=(self.haar_minSize, self.haar_minSize)
)
self.colors = dict(green=(0, 255, 0), red=(255, 0, 0))
self.recognizer = cv2.createLBPHFaceRecognizer()
self.imgPlayer = imtools.ImagePlayer(title='face detection')
self.save_folder = './tmp'
self.faces = []
self.rects = []
self.name_id = {}
self.name_rect = {}
self.target = 'abner'
self.frames = []
self.headers = []
self.frame_max = 30
def predict_image(face):
global variable_faces
num_iterations = 300
matches_this_iteration = 0
for j in xrange(num_iterations):
try:
listlabel=[]
recognizers = []
variable_faces = []
num_recognizers = 3
for j in xrange(num_recognizers):
lbh_recognizer = cv2.createLBPHFaceRecognizer()
recognizers.append(lbh_recognizer)
recognizers = train_recognizers(recognizers,listlabel)
average_confidence = 0
CONFIDENCE_THRESHOLD = 100.0
labels = []
for lbh_recognizer in recognizers:
[label, confidence] = lbh_recognizer.predict(np.asarray(face))
average_confidence += confidence
labels.append(label)
average_confidence /= num_recognizers
if len(set(labels))==1 and average_confidence < CONFIDENCE_THRESHOLD:
matches_this_iteration += 1
if matches_this_iteration == 3:
return (directory_name_to_display_name(findlabel(listlabel,labels[0])))
except:
continue
return None
def test_recognize_model_internal_models(self):
base_path = os.path.join('..', 'test_files', 'face_models')
face_rec_data = os.path.abspath(
os.path.join(base_path, 'face_rec_data'))
params = {c.GLOBAL_FACE_MODELS_MIN_DIFF_KEY: -1,
c.GLOBAL_FACE_REC_DATA_DIR_PATH_KEY: face_rec_data}
self.test_add_face()
fm = FaceModels(params)
fm.load_enabled_models()
model_id = 0
im_list = [os.path.join(base_path, '0000000_aligned.png'),
os.path.join(base_path, '0000005_aligned.png')]
model_path_0 = fm.create_model_from_image_list(im_list, model_id)
query_model = cv2.createLBPHFaceRecognizer()
query_model.load(model_path_0)
rec_results = fm.recognize_model(query_model)
print('rec_results', rec_results)
rec_result = rec_results[0]
self.assertEqual(rec_result[c.ASSIGNED_TAG_KEY], 3812)
def get_Faces_Labels_AndTrain(path , delay ):
recognizer = cv2.createLBPHFaceRecognizer()
print "\nMade the LBPH(LocalBinaryPatternHistogram) recognizer "
print "Adding PATH=",path
image_paths = [os.path.join(path,f) for f in os.listdir(path)if not f.endswith('.zzzzzzzzzzzzzz')]
faces = []
labels = []
count = 0;
for image_path in image_paths:
print " getting the image"
image_pil = Image.open(image_path).convert('L')
print "Conv. to GrayScale "
image_pil = np.array( image_pil , 'uint8' )
face = faceCascade.detectMultiScale( image_pil )
nbr = int(os.path.split(image_path)[1].split(".")[0].replace("subject", ""))
for (x, y, w, h) in face:
count= count +1
print "COUNT = " , count
faces.append(image_pil [y: y + h, x: x + w])
cv2.imshow("Adding faces to traning set...", image_pil[y: y + h, x: x + w])
cv2.waitKey(delay)
labels.append(nbr)
print "recognizer updated... NUMBER OF FACES =", len(faces) , "Number of Lables =" , len(labels)
recognizer.train(faces, np.array(labels))
print "LABEL_NUMBER=", nbr
if (count>3):
nbr_predicted, conf = recognizer.predict( image_pil[y: y + h, x: x + w])
print "PERCENT MATCH=",conf , "NUMBER PREDICTED = " , nbr_predicted
cv2.destroyAllWindows()
print "USED THE GET FACES FUNCTION"
return recognizer
def consume(self, frame, ROIs, ROIs_coordinates, faces):
if len(ROIs) == 1:
ROI_x = ROIs_coordinates[0][0]
ROI_y = ROIs_coordinates[0][1]
ROI_w = ROIs[0].shape[0]
ROI_h = ROIs[0].shape[1]
cv2.rectangle(frame, (ROI_x, ROI_y), (ROI_x+ROI_w, ROI_y+ROI_h), (0, 0, 255))
if not cv2.waitKey(1) & 0xFF == ord('p'):
return frame
if self.image_count == self.IMAGE_COUNT:
if self.ALREADY_TRAINED:
return
print str(self.image_count) + " images were captured. Training recognizer ..."
images, labels = self.get_images_and_labels(self.FACE_PATH)
recognizer = cv2.createLBPHFaceRecognizer()
self.train_recognizer(recognizer, images, labels)
self.EXIT_FLAG = True
return
if len(faces) > 1:
print "Detected more than one face. Skipping frame ..."
return None
if len(faces) == 0:
print "No faces in the image. Skipping frame ..."
return None
self.image_count += 1
cv2.imwrite(self.FACE_PATH + "/" + str(self.image_count) + self.FRAMECAPTURE_EXTENSION, ROIs[0])
print "Saved image!"
return frame
def refresh_data():
# Get path to all images
path = '../rsc/images'
image_paths = [os.path.join(path, f) for f in os.listdir(path)]
# Initialize empty lists for these images and labels
images = []
labels = []
for path in image_paths:
images.append(cv2.imread(path, cv2.CV_LOAD_IMAGE_GRAYSCALE))
labels.append(int(os.path.split(path)[1].split("_")[0]))
labels = array(labels)
# Create recognizers
eigen_recognizer = cv2.createEigenFaceRecognizer()
fisher_recognizer = cv2.createFisherFaceRecognizer()
lbhp_recognizer = cv2.createLBPHFaceRecognizer()
# Train recognizers
eigen_recognizer.train(images, labels)
fisher_recognizer.train(images, labels)
lbhp_recognizer.train(images, labels)
# Save results
eigen_recognizer.save(EIGEN_RECOGNIZER_PATH)
fisher_recognizer.save(FISHER_RECOGNIZER_PATH)
lbhp_recognizer.save(LBHP_RECOGNIZER_PATH)
def rePath(imgpath,xml="",csv='csv.txt'):
model = cv2.createLBPHFaceRecognizer()
model.load(xml+"face-lbph.yml")
try:
im = cv2.imread(imgpath, cv2.IMREAD_GRAYSCALE)
except IOError, (errno, strerror):
print "I/O error({0}): {1}".format(errno, strerror)
def trainImage(cur):
#first need to train sample images in database
recognizer = cv2.createLBPHFaceRecognizer()
#get training image path from database and train them
sql = "SELECT * FROM users"
cur.execute(sql)
images = []
labels = []
for row in cur.fetchall():
#need to modify the argument
label = row[0]
image_pil = Image.open(row[4]).convert('L')
image = np.array(image_pil, 'uint8')
#faces = cascade.detectMultiScale(image, 1.3, 5, minSize = (70, 70), flags = cv2.cv.CV_HAAR_SCALE_IMAGE)
faces = cascade.detectMultiScale(image)
# If face is detected, append the face to images and the label to labels
for (x, y, w, h) in faces:
cv2.imshow("Adding faces to traning set...", image[y: y + h, x: x + w])
images.append(image[y: y + h, x: x + w])
labels.append(row[0])
recognizer.train(images, np.array(labels))
return recognizer
def __init__(self,useGUI=False,debugWin=True,
drawFaceRct=True,
faceRecognize=True,faceRecognizeXmlfile=None):
self._useGUI=useGUI
self._debugWin=debugWin
self.drawFaceRct=drawFaceRct
#self.drawMoveRct=drawMoveRct
self.faceRecongnize=faceRecognize
self._recognizeFace_xml_file=faceRecognizeXmlfile
self._front=IOSteam()
self._detectFace=FaceTracker()
self._recognizeFace=cv2.createLBPHFaceRecognizer(neighbors=8)
self.displayFrame=None
try:
self._recognizeFace.load(self._recognizeFace_xml_file)
except:
logging.debug('[-]recognize DB xml file:{} fail to load'.format(
self._recognizeFace_xml_file))
logging.info( '[-]without DB xml ,recognize may be reported Error!')
#self._trackers=[]
self._faceLost=False
#self._faceReg_api=API(API_KEY, API_SECRET)
self._res=[]
self._mode=self.Available_Mode[0]
self.faceSetinSameFrame=[]
self.faceSetofImageinSameFrame=[]
self.faceSetofImageinSameFrameResized=[]
def main():
args = configureArguments()
configureLogging(args.log)
#faceSize = (100, 100)
faceSize = None
logging.debug('Creating face recognizer...')
#fr = cv2.createFisherFaceRecognizer()
fr = cv2.createLBPHFaceRecognizer()
#modelFile = '/home/juan/ciberpunks/faces/lpbFaceModel'
#if os.path.isfile(modelFile):
# fr.load(modelFile)
# logging.info('Loaded saved model state.')
#else:
trainPaths = [
'/home/juan/ciberpunks/faces/at&t_database',
'/home/juan/ciberpunks/faces/lfw2',
'/home/juan/ciberpunks/faces/prestico']
[images, labels, subjects] = readImages(trainPaths, faceSize)
logging.debug('Training face recognizer...')
fr.train(images, labels)
#fr.save(modelFile)
#logging.info('Saved a trained model state.')
logging.debug('Staring face recognition...')
#recognizePictureCandidates(fr, subjects, faceSize)
recognizeVideo(fr, args.videoFileName, subjects, args.haarFolder)
def train(path = './yalefaces/subject02', name = None):
"""
Takes in a path for a folder filled with training images for a specific subject.
It trains a recognizer for the person using the images. It then saves the recognizer in an .xml
file. For now, it saves all the recognizers in a folder called recognizers in the directory where
the code is located.
Args:
path (str): Path name of folder containing images
name (str): Name of the subject
Returns:
list : List of training images in an np.array form
list : Array of labels associated with every name
"""
if name is None:
name = path.split("/")[2]
#Create Recognizer object
recognizer = cv2.createLBPHFaceRecognizer()
#retrieve all the images nad labels associated with the training images
images, labels = get_image_and_labels(path)
#train recognizer with the images
recognizer.train(images, np.array(labels))
#save all recognizers in a subfolder
recognizer.save("./recognizers/{}.xml".format(name))
def intro():
cascadePath="haarcascade_frontalface_default.xml"
faceCascade=cv2.CascadeClassifier(cascadePath)
recognizer=cv2.createLBPHFaceRecognizer()
recognizer.load("rec.xml")
urllib.urlretrieve("http://192.168.0.100:81/snapshot.cgi?user=admin&pwd=googlevirus","detected.jpg")
predict_image_pil=Image.open("detected.jpg").convert('L')
predict_image=np.array(predict_image_pil)
faces = faceCascade.detectMultiScale(
predict_image,
scaleFactor=1.2,
minNeighbors=5,
minSize=(30, 30),
flags = cv2.cv.CV_HAAR_SCALE_IMAGE
)
print faces
d={"results":[]}
for (x,y,w,h) in faces:
nbr_predicted,conf=recognizer.predict(cv2.resize(predict_image[y:y+h,x:x+w],(40,40),interpolation=cv2.INTER_CUBIC))
print nbr_predicted,conf
if conf<=50.0:
print "hi"
if nbr_predicted==1:
data={"name":"Rishav","message":"hi master"}
print data
d["results"].append(data)
elif nbr_predicted==2:
data={"name":"Kushagra","message":"hi bhole"}
d["results"].append(data)
return json.dumps(d)
def get_images_and_labels(path):
# For face detection we will use the Haar Cascade provided by OpenCV.
cascadePath = "./config/haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
# For face recognition we will the the LBPH Face Recognizer
recognizer = cv2.createLBPHFaceRecognizer()
# Append all the absolute image paths in a list image_paths
# We will not read the image with the .sad extension in the training set
# Rather, we will use them to test our accuracy of the training
image_paths = [os.path.join(path, f) for f in os.listdir(path) if not f.endswith('.sad')]
# images will contains face images
images = []
# labels will contains the label that is assigned to the image
labels = []
for image_path in image_paths:
# Read the image and convert to grayscale
image_pil = Image.open(image_path).convert('L')
# Convert the image format into numpy array
image = np.array(image_pil, 'uint8')
# Get the label of the image
nbr = int(os.path.split(image_path)[1].split("_")[0])
# Detect the face in the image
faces = faceCascade.detectMultiScale(image)
# If face is detected, append the face to images and the label to labels
for (x, y, w, h) in faces:
images.append(image[y: y + h, x: x + w])
labels.append(nbr)
#cv2.imshow("Adding faces to traning set...", image[y: y + h, x: x + w])
#cv2.waitKey(50)
# return the images list and labels list
return images, labels
def learnCollectedFaces(preprocessedFaces, faceLabels, facerecAlgorithm, recognizer):
print "Learning the collected faces using the {0} algorithm...".format(facerecAlgorithm)
# Make sure the "contrib" module is dynamically loaded at runtime
# Requires OpenCV v2.4.1 or later (from June 2012), otherwise the FaceRecognizer will not compile or run
# haveContribModule =
# if not haveContribModule:
# print "contrib module is needed for facerecognizer"
# sys.exit()
# create recognizer depending on the defined algorithm
faceLabels = np.array(faceLabels)
if facerecAlgorithm == 'Fisherfaces':
recognizer = cv2.createFisherFaceRecognizer()
elif facerecAlgorithm == 'Eigenfaces':
recognizer = cv2.createEigenFaceRecognizer()
else:
recognizer = cv2.createLBPHFaceRecognizer()
# faceLabels = np.array(faceLabels)
print np.unique(faceLabels)
recognizer.train(preprocessedFaces, faceLabels)
return recognizer
def check_trainer_accuracy():
testRecognizer = cv2.createLBPHFaceRecognizer(neighbors=5)
(train_images, train_labels) = get_images_and_labels(TRAINING_DIR)
test_images = []
test_labels = []
for i in range(0, len(train_images)/10):
index = random.randrange(len(train_images)-1)
test_images.append(train_images[index])
test_labels.append(train_labels[index])
del train_images[index]
del train_labels[index]
train_label_codes = []
for label in train_labels:
train_label_codes.append(classification_utils.lookup_code(label))
testRecognizer.train(train_images, numpy.array(train_label_codes))
testRecognizer.save("recognizer.dat")
num_correct = 0;
for i in range(0, len(test_images)):
predicted_label_code, confidence = testRecognizer.predict(test_images[i])
actual_label = test_labels[i]
predicted_label = classification_utils.lookup_label(predicted_label_code)
if predicted_label == actual_label:
num_correct += 1
print("Correctly predicted with confidence", confidence)
else:
print("Incorrectly recognized", actual_label, "as", predicted_label)
print("Predicted with", float(num_correct)/float(len(test_images)), "accuracy")
def main():
parser = argparse.ArgumentParser()
lfwDefault = os.path.expanduser(
"~/openface/data/lfw/dlib.affine.sz:96.OuterEyesAndNose")
parser.add_argument('--lfwAligned', type=str,
default=lfwDefault,
help='Location of aligned LFW images')
parser.add_argument('--networkModel', type=str, help="Path to Torch network model.",
default=os.path.join(openfaceModelDir, 'nn4.small2.v1.t7'))
parser.add_argument('--largeFont', action='store_true')
parser.add_argument('workDir', type=str,
help='The work directory where intermediate files and results are kept.')
args = parser.parse_args()
# print(args)
if args.largeFont:
font = {'family': 'normal', 'size': 20}
mpl.rc('font', **font)
mkdirP(args.workDir)
print("Getting lfwPpl")
lfwPplCache = os.path.join(args.workDir, 'lfwPpl.pkl')
lfwPpl = cacheToFile(lfwPplCache)(getLfwPplSorted)(args.lfwAligned)
print("Eigenfaces Experiment")
cls = cv2.createEigenFaceRecognizer()
cache = os.path.join(args.workDir, 'eigenFacesExp.pkl')
eigenFacesDf = cacheToFile(cache)(opencvExp)(lfwPpl, cls)
print("Fisherfaces Experiment")
cls = cv2.createFisherFaceRecognizer()
cache = os.path.join(args.workDir, 'fisherFacesExp.pkl')
fishFacesDf = cacheToFile(cache)(opencvExp)(lfwPpl, cls)
print("LBPH Experiment")
cls = cv2.createLBPHFaceRecognizer()
cache = os.path.join(args.workDir, 'lbphExp.pkl')
lbphFacesDf = cacheToFile(cache)(opencvExp)(lfwPpl, cls)
print("OpenFace CPU/SVM Experiment")
net = openface.TorchNeuralNet(args.networkModel, 96, cuda=False)
cls = SVC(kernel='linear', C=1)
cache = os.path.join(args.workDir, 'openface.cpu.svm.pkl')
openfaceCPUsvmDf = cacheToFile(cache)(openfaceExp)(lfwPpl, net, cls)
print("OpenFace GPU/SVM Experiment")
net = openface.TorchNeuralNet(args.networkModel, 96, cuda=True)
cache = os.path.join(args.workDir, 'openface.gpu.svm.pkl')
openfaceGPUsvmDf = cacheToFile(cache)(openfaceExp)(lfwPpl, net, cls)
plotAccuracy(args.workDir, args.largeFont,
eigenFacesDf, fishFacesDf, lbphFacesDf,
openfaceCPUsvmDf, openfaceGPUsvmDf)
plotTrainingTime(args.workDir, argrs.largeFont,
eigenFacesDf, fishFacesDf, lbphFacesDf,
openfaceCPUsvmDf, openfaceGPUsvmDf)
plotPredictionTime(args.workDir, args.largeFont,
eigenFacesDf, fishFacesDf, lbphFacesDf,
openfaceCPUsvmDf, openfaceGPUsvmDf)
def trainModel(): global model [X,y] = readImg(SAVE_DIR) y = np.asarray(y, dtype=np.int32) # model = cv2.createEigenFaceRecognizer() model = cv2.createLBPHFaceRecognizer() model.train(np.asarray(X), np.asarray(y)) print 'finish training'
def runCapture(self):
imgdir = self._imagePath
cam = self._cam
cascade = self._cascade
faceSize= (90, 90)
model= cv2.createLBPHFaceRecognizer(threshold=70.0)
images,labels,namess = utils.retrain(imgdir,model,faceSize)
#print "Nouvel etat:",len(images),"images",len(namess),"personnes"
self.isSomebody = False
ret, img = cam.read()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#a voir si c'est necessaire
gray = cv2.equalizeHist(gray)
# dectection de visage
rects = cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5, minSize=(40, 40), flags=cv2.cv.CV_HAAR_SCALE_IMAGE) #flags = cv2.CASCADE_SCALE_IMAGE
# ne prend que la region de l'image qui nous interesse (le visage)
roi = None
if len(rects)>0:
(x, y, w, h) = rects[0]
# crop & resize it
roi = cv2.resize( gray[y:y+h, x:x+h], faceSize )
#calcule les coordonnees du rectangle et les affiche
xCentre1=(2*x+w)/2
yCentre1=(2*y+h)/2
xCentre=str(xCentre1)
yCentre=str(yCentre1)
centre="("+xCentre+":"+yCentre+")"
cv2.rectangle(img, (x,y),(x+w,y+h), (0,255,0),2)
if len(images)>0:
[p_label, p_confidence] = model.predict(np.asarray(roi))
name="unknown"
if p_label !=-1 :
name = namess[p_label]
self.isSomebody = True
cv2.putText( img, "%s %.2f %.2f" % (name,p_confidence,p_label),(x+10,y+20), cv2.FONT_HERSHEY_PLAIN,1.5, (0,255,0))
self.name = name
self.xPosition = xCentre1
self.yPosition = yCentre1
while True:
cv2.imshow('Face Recognition For Poppy', img)
k = cv2.waitKey(5) & 0xFF
# quitter avec Echap
if k == 27: break
def loadMyFaceBdd(self):
if (os.path.isfile(self.bddDirPath+'/'+self.getListeFilename())):
print '[myFaceBdd] Chargement de la liste des libelles'
self.loadListeLabels()
print '[myFaceBdd] Chargement de la base opencv'
self.loadOpencvBdd()
self.istrainOK = True;
else:
self.recognizer = cv2.createLBPHFaceRecognizer()
def recognizer(self): """ Creates new FaceRecognizer using Local Binary Patterns (LBP) Returns current recognizer object """ self.current_recognizer = cv2.createLBPHFaceRecognizer() self.current_recognizer.train(self.faces, np.array(self.index)) return self.current_recognizer
def load(self, db_file_name):
"""
Update the face models data structure from a file.
:type db_file_name: string
:param db_file_name: the name of the file containing
the dump of the face models data structure
:rtype: boolean
:returns: True if loading was successful
"""
if db_file_name is None:
'''
Set the name of database.
Algorithm :
LBP (Local Binary Pattern)
'''
db_file_name = self._db_name + '-' + self._algorithm
tags_file_name = db_file_name + '-Tags'
algorithm = ce.FACE_MODEL_ALGORITHM
if self._params is not None:
algorithm = self._params[ce.FACE_MODEL_ALGORITHM_KEY]
model = None
if algorithm == 'Eigenfaces':
model = cv2.createEigenFaceRecognizer()
elif algorithm == 'Fisherfaces':
model = cv2.createFisherFaceRecognizer()
elif algorithm == 'LBP':
model = cv2.createLBPHFaceRecognizer()
ok = False
if os.path.isfile(db_file_name) and (os.path.isfile(tags_file_name)):
if(not((ce.USE_TRACKING or ce.SIM_TRACKING or ce.USE_SLIDING_WINDOW)
and ce.LOAD_IND_FRAMES_RESULTS)):
model.load(db_file_name)
if not(model is None):
self.model = model
self._tags = utils.load_YAML_file(tags_file_name)
ok = True
print('\n### DB LOADED ###\n')
return ok
def train_user_images(user):
target = []
labels = []
for training_image in user.trainingimage_set.all():
target.append(read_image(training_image.image.file))
labels.append(0)
model = cv2.createLBPHFaceRecognizer()
model.train(numpy.asarray(target), numpy.asarray(labels))
model.save(settings.MODEL_IMAGES_ROOT + user.username + '.yml')
def load(model_path):
# load the face recognition instance and construct the OpenCV face recognizer
fr_path = model_path.replace('.model', '.cpikle')
# fri = cPickle.loads(open(fr_path).read())
fri = cPickle.loads(open(fr_path).read())
recognizer = cv2.createLBPHFaceRecognizer()
recognizer.load(model_path)
# construct and return the face recognizer
return FaceRecognizer(recognizer, trained=fri.trained, labels=fri.labels)
def __init__(self, algorithm='fisherface'):
self.algorithm = algorithm
if (algorithm == 'fisherface'):
self.model = cv2.createFisherFaceRecognizer()
elif (algorithm == 'eigenface'):
self.model = cv2.createEigenFaceRecognizer()
elif (algorithm == 'lbphf'):
self.model = cv2.createLBPHFaceRecognizer()
else:
raise ValueError('Unknown algorithm: "%s"!' % (algorithm,))
haarcascade_eye_tree_eyeglasses.xml haarcascade_mcs_leftear.xml
haarcascade_eye.xml haarcascade_mcs_lefteye.xml
haarcascade_frontalface_alt2.xml haarcascade_mcs_mouth.xml
haarcascade_frontalface_alt_tree.xml haarcascade_mcs_nose.xml
haarcascade_frontalface_alt.xml haarcascade_mcs_rightear.xml
haarcascade_frontalface_default.xml haarcascade_mcs_righteye.xml
haarcascade_fullbody.xml haarcascade_mcs_upperbody.xml
haarcascade_lefteye_2splits.xml haarcascade_profileface.xml
haarcascade_lowerbody.xml haarcascade_righteye_2splits.xml
haarcascade_mcs_eyepair_big.xml haarcascade_smile.xml
haarcascade_mcs_eyepair_small.xml haarcascade_upperbody.xml
'''
cascade_path = "haarcascade_frontalface_default.xml"
face_cascade = cv2.CascadeClassifier(cascade_path)
recognizer = cv2.createLBPHFaceRecognizer(1, 8, 8, 8, 123)
def get_images():
path = "media"
image_folder = os.path.abspath(
os.path.join(os.path.dirname(__file__), path))
image_paths = [
os.path.join(image_folder, f) for f in os.listdir(image_folder)
if f.endswith('.jpg')
]
images = []
labels = []
for image_path in image_paths:
gray = Image.open(image_path).convert('L')
image = np.array(gray, 'uint8')
def __init__(self, visitor_faces):
self.visitors = visitor_faces
self.model = cv2.createLBPHFaceRecognizer(
threshold=LBP_RECOGNITION_THRESHOLD)
self.face_cascade = cv2.CascadeClassifier(CASCADE_FILE)
def LBPHupdate(ID):
labels=[]
images=[]
# make sure this is the right file name
faceCascade = cv2.CascadeClassifier(cascadePath)
counter=0
#counter2=0
foldername=ID;
#update database
print 'Loading training data...'
model=cv2.createLBPHFaceRecognizer()
model.load(TRAINING_FILE)
print 'Training data loaded!'
f=open(CSV_FILE,'r+')
t=open(LOOKUP_FILE,'r+')
en=open(ENROLLMENT_FILE,'r+')
#Get label
f.seek(-10,2)
s=f.readline()
#print s
list=s.split(';')
num=str(list[1]).split('\n')
#new label no.
label=int(num[0])+1
#print label
f.seek(0,2)
t.seek(0,2)
en.seek(0,2)
faces=[]
labels=[]
DIRECTORY=foldername
#print DIRECTORY
SEPARATOR=";"
for files in os.listdir(DIRECTORY):
abs_path="%s\%s"%(DIRECTORY,files)
seq=''.join([str(abs_path),str(SEPARATOR),str(label),'\n'])
f.write(seq)
t.write(''.join([str(DIRECTORY),';',abs_path,';\n']));
en.write(''.join([str(label),'\n']))
f.close()
t.close()
en.close()
for filename in walk_files(DIRECTORY,'*.pgm'):
#print filename
faces.append(prepare_image(filename))
labels.append(label)
model.update(np.asarray(faces), np.asarray(labels))
#print model
#Save model results
model.save(TRAINING_FILE)
print 'Training data saved to',TRAINING_FILE
print "successfully updated"
def Authenticate():
#load lookup table_ ky
tableName=LOOKUP_FILE
table=[]
samples=[]
load_table(tableName,table,samples)
# Create window
cv2.namedWindow("Preview")
#cv2.namedWindow("Compared")
# Load training data into model
print 'Loading training data...'
model = cv2.createLBPHFaceRecognizer()
model.load(TRAINING_FILE)
print 'Training data loaded!'
confidences=[]
labels=[]
camera=PiCamera()
camera.resolution=(320,240)
camera.framerate=32
rawCapture=PiRGBArray(camera,size=(320,240))
time.sleep(3)
count=30
recognition=0
print 'Looking for face...'
camera.capture(rawCapture,format="bgr",use_video_port=True)
while rawCapture is not None:
image=rawCapture.array
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
result=face.detect_single(gray)
cv2.imshow("Preview",image)
key=cv2.waitKey(1)
if result is None:
print "Please face to the camera "
else:
x, y, w, h = result
# Crop and resize image to face
crop = face.resize(face.crop(gray, x, y, w, h))
label, confidence = model.predict(crop)
confidences.append(confidence)
labels.append(label)
cv2.waitKey(1)
count -= 1
if count<=0:
break
rawCapture.truncate(0)
camera.capture(rawCapture,format="bgr",use_video_port=True)
print "finish capturing faces"
camera.close()
cv2.destroyWindow("Preview")
temp=[]
i=0
length=len(labels)
while length>0:
if i==0:
temp.append(labels[length-1])
i += 1
length -= 1
else:
tempi=0
while tempi<i:
if labels[length-1]!=temp[tempi]:
tempi += 1
else:
length -=1
break
if tempi == i:
temp.append(labels[length-1])
i += 1
length -= 1
print "------LABELS:{}".format(labels)
print "------DIFFERENT LABELS:{}".format(temp)
print "------NUMBER OF DIFFERENT LABELS:{}".format(i)
tempi=0
numoflabel=0
if i > 5:
print "could not enter"
#print labels
return 0,-1
else:
element=temp[tempi]
while tempi < i:
tempj=0
count=0
while tempj<len(labels):
if labels[tempj]==temp[tempi]:
count += 1
tempj += 1
if count > numoflabel :
numoflabel=count
element=temp[tempi]
tempi += 1
print "element is {}, numoflabel is {}".format(element, numoflabel)
tempi = 0
con=0
while tempi < len(labels):
if labels[tempi]==element:
con=con+confidences[tempi]
tempi += 1
ave=con/numoflabel
print "mean of confidences is {}".format(ave)
print confidences
# print recognition
f=open(ENROLLMENT_FILE,'r')
s=f.readline()
flag=0
while s!="":
index=int(s)
#print index
if index==element:
flag=1
print "flag TRUE"
break
s=f.readline()
if ave < 50 and flag==1:
print "authenticated"
return 1,element
else:
print "could not enter"
return 0,-1
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
import numpy as np
#import cv2.face
import glob
import random
import sys
import cv2
emotions = ["neutrality", "anger", "fear", "happiness", "sadness", "surprise"]
fishface = cv2.createFisherFaceRecognizer()
eigenface = cv2.createEigenFaceRecognizer()
LBPface = cv2.createLBPHFaceRecognizer()
def detect_target_faces():
flag = 0
face_img = cv2.imread('face.jpg')
face_gray = cv2.cvtColor(face_img, cv2.COLOR_BGR2GRAY)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
face_gray = clahe.apply(face_gray)
faceDet = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
faceDet2 = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")
faceDet3 = cv2.CascadeClassifier("haarcascade_frontalface_alt.xml")
faceDet4 = cv2.CascadeClassifier("haarcascade_frontalface_alt_tree.xml")
face = faceDet.detectMultiScale(face_gray,
scaleFactor=1.1,
minNeighbors=10,
minSize=(5, 5),
from os.path import isfile,join
data_path = 'D:\\opencv2\\project_code\\code\\DataSet\\'
onlyfiles = [f for f in listdir(data_path) if isfile(join(data_path,f))]
Training_Data,Labels = [],[]
for i,files in enumerate(onlyfiles):
image_path = data_path + onlyfiles[i]
images = cv2.imread(image_path,cv2.IMREAD_GRAYSCALE)
Training_Data.append(np.asarray(images,dtype = np.uint8))
Labels.append(i)
Labels = np.asarray(Labels,dtype = np.int32)
model = cv2.createLBPHFaceRecognizer()
model.train(np.asarray(Training_Data),np.asarray(Labels))
print "Model training Done !!"
face_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
def face_detector(img,size=0.5):
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
faces = face_classifier.detectMultiScale(gray,1.3,5,0)
if faces is ():
return img,[]
for (x,y,w,h) in faces:
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi = img[y:y+h,x:x+w]
roi = cv2.resize(roi,(200,200))
class Detector:
# Intancias das outras classes
dbHelper = databaseHelper.DbHelper()
trainning = trainer.Trainer()
# Modelo a ser detectado
haarCascade = '../haarcascade/haarcascade_frontalface_alt.xml'
faceDetect = cv2.CascadeClassifier(haarCascade)
# Preparar camera
camera = cv2.VideoCapture(0)
# Preparar reconhecedor (raio, vizinhos, tabela_x, tabela_y, confianca)
recognizer = cv2.createLBPHFaceRecognizer(1, 8, 8, 8, 100)
# Fontes
textFont = cv2.cv.InitFont(cv2.cv.CV_FONT_HERSHEY_COMPLEX_SMALL, 1.5, 1, 0,
2)
controlsFont = cv2.FONT_HERSHEY_SIMPLEX
# Propriedades das amostras
userIdSample = 0
userNameSample = ''
sampleId = 0
# Flag para ligar o modo captura
captureMode = False
# wxPython (GUI)
dialog = wx.App()
# Carreagar Treino Padrão
recognizer.load("trainning\\data.yml")
# Alerta com input do nome
def getUserName(parent=None):
dlg = wx.TextEntryDialog(parent, 'Qual o seu nome?')
dlg.ShowModal()
result = dlg.GetValue()
dlg.Destroy()
return result
while (True):
frame, image = camera.read()
grayConvert = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = faceDetect.detectMultiScale(grayConvert, 1.3, 5)
for (x, y, w, h) in faces:
userId, conf = recognizer.predict(grayConvert[y:y + h, x:x + w])
userName = dbHelper.getNameById(userId)
if (userId == -1 or not (userName)):
userName = "******"
# Retangulo e nome do usuario
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.cv.PutText(cv2.cv.fromarray(image), userName, (x, y + h),
textFont, (0, 0, 255))
# Iniciar Captura
if (captureMode == True):
sampleId = sampleId + 1
cv2.imwrite(
'samples/' + userNameSample + '.' + str(userIdSample) +
'.' + str(sampleId) + '.jpg', grayConvert[y:y + h,
x:x + w])
cv2.putText(image, 'Capturando...', (420, 30), controlsFont, 1,
(255, 255, 255), 2, cv2.CV_AA)
cv2.waitKey(10)
# Terminar captura e treinar
if (sampleId > 20):
sampleId = 0
captureMode = False
trainning.train()
recognizer = cv2.createLBPHFaceRecognizer(1, 8, 8, 8, 100)
recognizer.load("trainning\\data.yml")
# Demais textos
cv2.putText(image, 'Faculdade Ateneu', (10, 30), controlsFont, 1,
(255, 255, 255), 2, cv2.CV_AA)
cv2.putText(image, 'Controles:', (10, 350), controlsFont, 1,
(255, 255, 255), 2, cv2.CV_AA)
cv2.putText(image, 'N -> Novo rosto', (20, 390), controlsFont, 0.7,
(255, 255, 255), 2, cv2.CV_AA)
cv2.putText(image, 'Q -> Sair', (20, 430), controlsFont, 0.7,
(255, 255, 255), 2, cv2.CV_AA)
cv2.putText(image, 'Criadores: David e Jadson', (420, 450),
controlsFont, 0.5, (255, 255, 255), 1, cv2.CV_AA)
cv2.putText(image, 'Versao: 1.0.0', (420, 470), controlsFont, 0.5,
(255, 255, 255), 1, cv2.CV_AA)
# Tela
cv2.imshow("Face Detector", image)
# Sair da aplicação
if (cv2.waitKey(1) == ord('q')):
break
# Nova leitura
if (cv2.waitKey(1) == ord('n')):
dialog.MainLoop()
userNameSample = getUserName()
if (userNameSample):
captureMode = True
dbHelper.firstOrUpdate(userNameSample)
userIdSample = dbHelper.getIdByName(userNameSample)
camera.release()
cv2.destroyAllWindows()
def main_loop(csv_file, use_ff=False):
# Open the cascade file and create the classifier
cascade_file = 'cascades/lbpcascade_frontalface.xml'
lbp_cascade = cv2.CascadeClassifier(cascade_file)
# Parse the CSV file
images_gray, labels, names = parse_csv(csv_file)
# Create the appropriate model for recognition
if use_ff:
model = cv2.createFisherFaceRecognizer()
else:
model = cv2.createLBPHFaceRecognizer(
threshold=LBP_RECOGNITION_THRESHOLD)
# Train the model with the gray-scale images and the labels
model.train(images_gray, labels)
# Open the default capture device (webcam)
capture = cv2.VideoCapture(-1)
while True:
_, frame = capture.read()
key = 0xFF & cv2.waitKey(10)
if key == 27:
break
elif key == 13 or key == 10:
# Convert the captured frame to grayscale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Try to detect faces
faces = lbp_cascade.detectMultiScale(gray, minSize=(30, 30))
for (x, y, w, h) in faces:
# Crop to the face Region of Interest
face_roi = gray[y:y + h, x:x + w]
# Only for fisher faces and eigen faces resize the face
face_resized = cv2.resize(face_roi, (92, 112), 1, 1,
cv2.INTER_CUBIC)
if use_ff:
# face_resized = cv2.resize(face_roi, (92, 112), 1, 1, cv2.INTER_CUBIC)
prediction, confidence = model.predict(face_resized)
else:
# prediction, confidence = model.predict(face_roi)
prediction, confidence = model.predict(face_resized)
name = "Desconocido" if prediction < 0 else names[prediction]
# Draw the predicted name and confidence above the face
text = "Prediction = %s Confidence = %s" % (name, confidence)
cv2.putText(frame, text, (x - 15, y - 15),
cv2.FONT_HERSHEY_PLAIN, 1.0, BLUE, 2)
# Draw a rectangle around the face
cv2.rectangle(frame, (x, y), (x + w, y + h), GREEN, 1)
cv2.imshow('Processed face', face_resized)
cv2.imshow('Face', frame)
cv2.imshow('LBPTest', frame)
import numpy as np
import cv2
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
cap = cv2.VideoCapture(0)
rec = cv2.createLBPHFaceRecognizer(2, 130)
rec.load("recognizer\\trainingData.yml")
id = 0
font = cv2.cv.InitFont(cv2.cv.CV_FONT_HERSHEY_COMPLEX_SMALL, 3, 1, 0, 3)
while 1:
ret, img = cap.read()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
id, conf = rec.predict(gray[y:y + h, x:x + w])
if (id == 1):
id = "Grish"
elif (id == 2):
id = "UnknowN"
elif ():
id = "unknown"
cv2.cv.PutText(cv2.cv.fromarray(img), str(id), (x, y + h), font, 255)
roi_gray = gray[y:y + h, x:x + w]
roi_color = img[y:y + h, x:x + w]
#For Live Video from Webcams
import cv2
import os
import numpy as np
import sys
recognizer=cv2.createLBPHFaceRecognizer()
recognizer.load("TrainData.yml")# loading Trained Data
faceCascade=cv2.CascadeClassifier("haarcascade_frontalface_default.xml");
test = cv2.imread(imageName,cv2.IMREAD_GRAYSCALE)#converting to gray scale
faces=faceCascade.detectMultiScale(test)
#font=cv2.cv.InitFont(cv2.cv.CV_FONT_HERSHEY_COMPLEX_SMALL,2,1,0,2)
i=0
lab=[]
cap=cv2.VideoCapture(0)#Video cam id
while(True):
ret,frame=cap.read()
#test=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
test = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces=faceCascade.detectMultiScale(test)
for(x,y,w,h) in faces:
if(w>80 and h>80):
predicted_label,confidence=recognizer.predict(test[y:y+h,x:x+w])
if confidence<100:
lab.append(predicted_label)
#cv2.rectangle(test,(x,y),(x+w,y+h),(255,255,255),2)
#cv2.cv.PutText(cv2.cv.fromarray(test),result,(x,y+h),font,255);
lab.sort()
lines=[]
file=open("FindLabel.txt","r+")# correspoinding names for the labels is saved in FindLabel.txt
from imutils import encodings
import numpy as np
import argparse
import random
import glob
import cv2
# construct the argument parse and parse command line arguments
ap = argparse.ArgumentParser()
ap.add_argument("-s", "--selfies", required=True, help="path to the selfies directory")
ap.add_argument("-c", "--classifier", required=True, help="path to the output classifier directory")
ap.add_argument("-n", "--sample-size", type=int, default=100, help="maximum sample size for each face")
args = vars(ap.parse_args())
# initialize the face recognizer and the list of labels
fr = FaceRecognizer(cv2.createLBPHFaceRecognizer(radius=1, neighbors=8, grid_x=8, grid_y=8))
labels = []
# loop over the input faces for training
for (i, path) in enumerate(glob.glob(args["selfies"] + "/*.txt")):
# extract the person from the file name,
name = path[path.rfind("/") + 1:].replace(".txt", "")
print("[INFO] training on '{}'".format(name))
# load the faces file, sample it, and initialize the list of faces
sample = open(path).read().strip().split("\n")
sample = random.sample(sample, min(len(sample), args["sample_size"]))
faces = []
# loop over the faces in the sample
for face in sample:
def __init__(self, script_path):
shutil.rmtree(
'/home/ros/robocup/src/beginner_tutorials/launch/dataset')
shutil.rmtree('/home/ros/robocup/src/beginner_tutorials/launch/person')
shutil.rmtree(
'/home/ros/robocup/src/beginner_tutorials/launch/recognizer')
os.mkdir('/home/ros/robocup/src/beginner_tutorials/launch/dataset')
os.mkdir('/home/ros/robocup/src/beginner_tutorials/launch/person')
rospy.loginfo("In the __init__()")
#initialize the node.
rospy.init_node('who is who')
rospy.on_shutdown(self.cleanup)
#set the voice
self.voice = rospy.get_param("~Voice", "voice_don_diphone")
self.wavepath = rospy.get_param("~wavepath",
script_path + "/../sounds")
self.soundhandle = SoundClient()
self.exit_point = PoseStamped()
rospy.sleep(1)
self.soundhandle.stopAll()
rospy.sleep(3)
self.sub = rospy.Subscriber('/start', String, self.getin)
self.pub = rospy.Publisher("/cmd_vel", Twist, queue_size=10)
self.sub2 = rospy.Subscriber('/odom', Odometry, self.get_x)
#send the sign of ready.
self.soundhandle.say("I am ready", self.voice)
rospy.loginfo("Say one of the navigation commands...")
#All subscribers and publishers are defined here
rospy.Subscriber('/recognizer/output', String, self.talkback)
self.sub_begin = rospy.Subscriber("begin", Int16, self.callback_begin)
self.voice_vel_pub = rospy.Publisher('who_voice', String, queue_size=5)
self.point_pub = rospy.Publisher('move_base_simple/goal',
PoseStamped,
queue_size=5)
self.peopleposepub = rospy.Publisher("people_pose_info", PeoplePose)
self.x = 0
#the word dictionary
#need to edit
self.keywords_to_command = {
'water': ['water'],
'coffee': ['coffee'],
'red bull': ['red bull', 'red', 'bull'],
'cola': ['cola'],
'paper': ['paper'],
'michael': ['michael'],
'jack': ['jack'],
'fisher': ['fisher'],
'kevin': ['kevin'],
'daniel': ['daniel'],
'yes': ['yes'],
'no': ['no']
}
self.srcfile = '/home/ros/robocup/src/beginner_tutorials/launch/WhoIsWho_yaml/trainningdata.yml'
self.dstfile = '/home/ros/robocup/src/beginner_tutorials/launch/recognizer/trainningdata.yml'
self.copyfile()
self.name = [[0 for i in range(2)] for i in range(6)]
self.position = [[0 for i in range(3)] for i in range(6)]
self.flag_begin = 0
self.people_num = 0
self.tempname = ''
self.talk_flag = 0
self.frame = None
self.array = None
self.face_rects = None
self.face_rects_judge = None
self.scaling_factor = 1.0
self.num = 0
self.i = 0
self.a = 0
self.end = 450
self.flag_face_detect = 0
self.recognize = 0
self.recognizer = cv2.createLBPHFaceRecognizer()
self.face_cascade = cv2.CascadeClassifier(
'/usr/share/opencv/haarcascades/haarcascade_frontalface_alt.xml')
self.begin = time.time()
self.quaternion_get_into_the_door = [0, 0, 0.016557, -0, 999863]
self.quaternion_get_into_the_room = [0, 0, 0.003117, -0.999995]
self.pos_get_into_the_door = [11.18065, 5.967353, 0]
self.pos_get_into_the_room = [12.8934, 3.3162, 0]
self.euler_point = [11.9269, 3.2924, 0]
self.quaternion_go_to_the_exit = [0, 0, 0.999756, -0.022053] #gai
self.pos_go_to_the_exit = [10.616634, 0.949925, 0] #gai
#initialize move_base
self.move_base_client = actionlib.SimpleActionClient(
'move_base', MoveBaseAction)
connected_befor_timeout = self.move_base_client.wait_for_server(
rospy.Duration(2.0))
if connected_befor_timeout:
rospy.loginfo('succeeded connecting to move_base server')
else:
rospy.logerr('failed connecting to move_base server')
return
rospy.wait_for_service('move_base/clear_costmaps', 5.0)
self.service_clear_costmap_client = rospy.ServiceProxy(
'move_base/clear_costmaps', Empty)
rospy.loginfo('connected to move_base/clear_costmaps')
rospy.loginfo('node initialized')
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
import cv2 # OpenCV Library
import lib.face as face
import lib.config as config
import time
import os
# Load training data into model
print('Loading training data...')
if config.RECOGNITION_ALGORITHM == 1:
print "ALGORITHM: LBPH"
model = cv2.createLBPHFaceRecognizer(threshold=config.POSITIVE_THRESHOLD)
elif config.RECOGNITION_ALGORITHM == 2:
print "ALGORITHM: Fisher"
model = cv2.createFisherFaceRecognizer(threshold=config.POSITIVE_THRESHOLD)
else:
print "ALGORITHM: Eigen"
model = cv2.createEigenFaceRecognizer(threshold=config.POSITIVE_THRESHOLD)
model.load("training.xml")
print('Training data loaded!')
camera = config.get_camera()
time.sleep(1) # give the camera a second to warm up
while True:
# camera video feed
reference_faces_paths = sorted(
glob.glob(args.reference_faces_path + "*.pgm"))
for path in reference_faces_paths:
index = int(path[path.rfind('/') + 1:path.rfind('.')])
reference_faces_indices.append(index)
face_img = cv2.imread(path)
reference_faces_images.append(face_img)
reference_faces = dict(zip(reference_faces_indices,
reference_faces_images))
if args.facerec_method == "eigenfaces":
face_recognizer = cv2.createEigenFaceRecognizer(0, args.facerec_threshold)
elif args.facerec_method == "fisherfaces":
face_recognizer = cv2.createFisherFaceRecognizer(0, args.facerec_threshold)
elif args.facerec_method == "lbph":
face_recognizer = cv2.createLBPHFaceRecognizer(1, 8, 8, 8,
args.facerec_threshold)
else:
pass
try:
face_recognizer.load(args.facerec_model_path)
except:
print "Something went wrong face recognizer model, exiting..."
sys.exit(1)
train_face_size = (96, 96)
indexes = [
1, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27
]
ok = 0
