def enroll(request):
captured = False
while not captured:
try:
if request.method == 'POST' and request.FILES['image']:
myfile = request.FILES['image']
fs = FileSystemStorage()
filename = fs.save(myfile.name, myfile)
# print(filename)
name = request.POST.get('name')
description = request.POST.get('description')
location = request.POST.get('location')
date = request.POST.get('date')
x = ("" + filename + "")
detail_obj = Details(name=name,
description=description,
location=location,
date=date,
image=fs.url(x))
print(x)
detail_obj.save()
kairos_face.enroll_face(file=BASE_DIR + "/media/" +
fs.url(filename),
subject_id=str(detail_obj.id),
gallery_name='a-gallery')
captured = True
messages.add_message(request, messages.SUCCESS,
'Successfully enrolled!')
return render(request, 'enroll.html')
except kairos_face.exceptions.ServiceRequestError:
messages.add_message(request,
messages.ERROR,
'Error! No face found in the image',
extra_tags='safe')
return render(request, 'enroll.html')
def add_face_fn(img_path):
# reading new member id to be used as subject id
user_id = input("enter your member id : ")
# Enrolling from a file
kf.enroll_face(file=img_path, subject_id=user_id, gallery_name='students')
def enroll(request):
try:
cur = connection.cursor()
logging.info('DB connected')
except:
logging.info('Db connection error')
kairos_face.settings.app_id = 'Your APP ID'
kairos_face.settings.app_key = 'Your App key'
if request.method == 'POST':
#POST goes here . is_ajax is must to capture ajax requests.
if request.is_ajax():
uname = request.POST.get('uname')
gallery = request.POST.get('gallery')
image = request.POST.get('image')
try:
kairos_face.enroll_face(file=image,
subject_id=uname,
gallery_name=gallery)
result = 'success'
except:
print('Coudn\'t Enroll! Try again')
result = 'Error'
data = {'uname': uname, 'gallery': gallery, 'result': result}
return JsonResponse(data)
return render(request, 'enroll.html')
def test_raises_exception_when_http_response_body_contains_error_field(self):
response_body = '{"Errors": "something something dark side..."}'
responses.add(responses.POST, 'https://api.kairos.com/enroll', status=200,
body=response_body)
with self.assertRaises(kairos_face.ServiceRequestError):
kairos_face.enroll_face('sub_id', 'gallery', url='a_image_url.jpg')
def enroll(image, id, gname):
'''Takes three arguments image=image_path, id=subject_id and gname=gallery_name'''
# Enrolling from a URL
# kf.enroll_face(url='', subject_id='sub', gallery_name='test')
# Enrolling from a file
#passing image_path of the image which is to be enrolled, subject_id: name from which it should be enrolled, gallery_name: in which gallery it shoud be enrolled
kf.enroll_face(file=image, subject_id=id, gallery_name=gname)
def test_passes_api_url_in_post_request(self, post_mock):
post_mock.return_value.status_code = 200
kairos_face.enroll_face('sub_id', 'gallery', url='image')
args, _ = post_mock.call_args
self.assertEqual(1, len(args), 'No positional arguments were passed to post request')
self.assertEqual('https://api.kairos.com/enroll', args[0])
def test_passes_app_id_and_key_in_post_header(self, post_mock):
post_mock.return_value.status_code = 200
kairos_face.enroll_face('sub_id', 'gallery', url='a_image_url.jpg')
_, kwargs = post_mock.call_args
expected_headers = {
'app_id': 'app_id',
'app_key': 'app_key'
}
self.assertTrue('headers' in kwargs)
self.assertEqual(expected_headers, kwargs['headers'])
def test_passes_required_arguments_in_payload_as_json_when_image_is_url(self, post_mock):
post_mock.return_value.status_code = 200
kairos_face.enroll_face('sub_id', 'gallery', url='a_image_url.jpg')
_, kwargs = post_mock.call_args
expected_payload = {
'image': 'a_image_url.jpg',
'subject_id': 'sub_id',
'gallery_name': 'gallery',
'multiple_faces': False
}
self.assertTrue('json' in kwargs)
self.assertEqual(expected_payload, kwargs['json'])
def test_passes_required_arguments_in_payload_as_json_when_image_is_file(self, post_mock):
post_mock.return_value.status_code = 200
m = mock.mock_open(read_data=str.encode('test'))
with mock.patch('builtins.open', m, create=True):
kairos_face.enroll_face('sub_id', 'gallery', file='/a/image/file.jpg')
_, kwargs = post_mock.call_args
expected_payload = {
'image': 'dGVzdA==',
'subject_id': 'sub_id',
'gallery_name': 'gallery',
'multiple_faces': False
}
self.assertTrue('json' in kwargs)
self.assertEqual(expected_payload, kwargs['json'])
def test_passes_additional_arguments_in_payload(self, post_mock):
post_mock.return_value.status_code = 200
additional_arguments = {
'selector': 'SETPOSE',
'symmetricFill': True
}
kairos_face.enroll_face('sub_id', 'gallery',
url='a_image_url.jpg', additional_arguments=additional_arguments)
_, kwargs = post_mock.call_args
passed_payload = kwargs['json']
self.assertTrue('selector' in passed_payload)
self.assertEqual('SETPOSE', passed_payload['selector'])
self.assertTrue('symmetricFill' in passed_payload)
self.assertEqual(True, passed_payload['symmetricFill'])
def register_face():
save_image(request.form['image'], 'face.jpg')
print(
kairos_face.enroll_face(file='face.jpg',
subject_id=request.form['name'],
gallery_name='hackathon'))
return 'finished'
def image_cap():
print('entered')
if request.method == 'POST':
# get data from register form
name = request.form['name']
number = int(request.form['number'])
email = request.form['email']
password = request.form['password']
# capture image---> save----> release cam
cam = cv2.VideoCapture(0)
frame = cam.read()[1]
cv2.imwrite('face.jpg', frame)
cam.release()
# enroll face with subject id email
enrolled_face = kf.enroll_face(file='face.jpg',
subject_id=str(email),
gallery_name='a-gallery')
# get face id
face_id = enrolled_face['face_id']
# status T/F face enrlled or not
status = enrolled_face['images'][0]['transaction']['status']
if status == "success":
# execute query to insert data
out = cursor.execute(
'insert into flask_use values("%s","%d","%s","%s","%s")' %
(name, number, email, password, face_id))
conn.commit()
return render_template('image_cap.html')
else:
return '<h1>Non-Human detected</h1>'
def enroll_image(location, sub_id):
print(location)
print(type(sub_id))
print(sub_id)
enrolled_face = kairos_face.enroll_face(file=location,
subject_id=str(sub_id),
gallery_name='Demo')
print(enrolled_face)
def enroll_student(sid, img_path='face.jpg'):
enrolled_face = kf.enroll_face(file=img_path,
subject_id=str(sid),
gallery_name='a-gallery')
status = enrolled_face['images'][0]['transaction']['status']
if status == "success":
return "enrolled"
elif status == "failure":
return "failure"
def enroll_student(sid, img_path='face.jpg'):
#enrolling face
enrolled_face = kf.enroll_face(file=img_path,
subject_id=str(sid),
gallery_name='students')
#returning status
status = enrolled_face['images'][0]['transaction']['status']
if status == 'success':
return "enrolled"
def enroll(self):
import kairos_face
images = ['image_%s' % i for i in range(1, 5)]
for img in images:
attr = getattr(self, img, None)
if attr:
response = kairos_face.enroll_face(
url=attr.url,
subject_id=str(self.id),
gallery_name=settings.KAIROS_GALLERY)
return response
def doWinston(dct):
global location
idd = -1
dct['frames'][0]['people'][0]['location'] = location
try:
#Try to find current person in database, if not, enroll them
ans = kairos_face.recognize_face(file='image.png', gallery_name='test')
if 'Errors' in ans:
print ans['Errors'][0]['Message']
elif len(ans['images'][0]['candidates']) == 0:
print "Nobody found! Time to enroll!"
idd = hex(random.randint(1, 100000000000))
enr = kairos_face.enroll_face(file='image.png',
subject_id=idd,
gallery_name='test')
dct['frames'][0]['people'][0]['id'] = idd
requests.post(
"https://za4fvvbnvd.execute-api.us-east-2.amazonaws.com/Hackathon/emotions",
json=dct)
else:
idd = ans['images'][0]['transaction']['subject_id']
print idd + " welcome back!"
dct['frames'][0]['people'][0]['id'] = idd
requests.post(
"https://za4fvvbnvd.execute-api.us-east-2.amazonaws.com/Hackathon/emotions",
json=dct)
except:
#Runs if gallery not found (database dumped)
print "Nobody found! Time to enroll!"
try:
idd = hex(random.randint(1, 100000000000))
enr = kairos_face.enroll_face(file='image.png',
subject_id=idd,
gallery_name='test')
dct['frames'][0]['people'][0]['id'] = idd
requests.post(
"https://za4fvvbnvd.execute-api.us-east-2.amazonaws.com/Hackathon/emotions",
json=dct)
except Exception, e:
print e
def test_returns_face_id_from_kairos_response(self):
response_dict = {
'images': [{
'transaction': {'face_id': 'new_face_id'},
'attributes': {}
}]
}
responses.add(responses.POST, 'https://api.kairos.com/enroll', status=200,
body=(json.dumps(response_dict)))
face_id, _ = kairos_face.enroll_face('sub_id', 'gallery', url='a_image_url.jpg')
self.assertEqual('new_face_id', face_id)
def showRefugee(request):
if request.method == "POST":
form = RefugeeForm(request.POST, request.FILES)
if form.is_valid():
refugee = form.save(commit=False)
refImage = request.FILES["refImage"]
fs = FileSystemStorage()
filePath = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))
filePath = filePath + '/media/' + str(
refugee.pk) + refImage.name[-4:]
fs.save(filePath, refImage)
recognized_faces = kairos_face.recognize_face(
file=filePath, gallery_name=gallery_name)
print(recognized_faces)
try:
confidence = recognized_faces["images"][0]["candidates"][0][
"confidence"]
if (confidence > 0.7):
print("You are fraud")
form = RefugeeForm()
return render(request, 'RefugeeForm.html', {'form': form})
except KeyError:
pass
kairos_face.enroll_face(file=filePath,
subject_id=str(refugee.pk),
gallery_name=gallery_name)
refugee.bID = request.user.username
refugee.save()
return redirect('/bo/refugeeCard/' + str(refugee.pk))
else:
form = RefugeeForm()
return render(request, 'RefugeeForm.html', {'form': form})
def addPerson(faces, database_naam, NumberOfFacesPerPerson, NumberOfPersonsInDB, verbose, chillMode):
if verbose:
print('Adding {} files to {}'.format(NumberOfFacesPerPerson*NumberOfPersonsInDB, database_naam))
personsInDatabase = []
k = 0
bar = tqdm(total=NumberOfPersonsInDB*NumberOfFacesPerPerson)
while k < len(faces) and len(personsInDatabase) < NumberOfPersonsInDB*NumberOfFacesPerPerson:
if k%20 == 0:
for face in tqdm(range(NumberOfFacesPerPerson), leave = True):
bar.update()
try:
kairos_face.enroll_face(file=facesmap + faces[face+k], subject_id=str(k+1), gallery_name=database_naam)
personsInDatabase.append(k+1)
if chillMode:
time.sleep(2)
except Exception as e:
if verbose:
print(bcolors.FAIL + "ERROR ADD PERSON: {}".format(e) + bcolors.ENDC)
time.sleep(30)
try:
kairos_face.enroll_face(file=facesmap + faces[face+k], subject_id=str(k+1), gallery_name=database_naam)
personsInDatabase.append(k+1)
if chillMode:
time.sleep(2)
except Exception as e:
if verbose:
print(bcolors.FAIL + "ERROR ADD PERSON: {}".format(e) + bcolors.ENDC)
else:
pass
if str(e).find('Max retries exceeded') > -1:
time.sleep(60)
k += 1
bar.close()
return personsInDatabase
def test_image_response_is_returned(self):
try:
face_id, attributes = kairos_face.enroll_face(
'integration-test-face',
'integration-test-gallery',
url=self.face_example_url)
self.assertIsNotNone(face_id)
self.assertEqual('M', attributes['gender']['type'])
except ServiceRequestError as e:
traceback.print_exc()
self.fail("This should not be raising an exception...")
finally:
kairos_face.remove_face(subject_id='integration-test-face',
gallery_name='integration-test-gallery')
def test_image_response_is_returned(self):
try:
response = kairos_face.enroll_face(
'integration-test-face',
'integration-test-gallery',
url=self.face_example_url
)
self.assertIsNotNone(response['face_id'])
self.assertEqual('M', response['images'][0]['attributes']['gender']['type'])
except ServiceRequestError:
traceback.print_exc()
self.fail('This should not be raising an exception...')
finally:
kairos_face.remove_face(subject_id='integration-test-face',
gallery_name='integration-test-gallery')
def result():
global user_mobile
result = request.form
for data in result.items():
register_data.append(data)
name = register_data[0]
user_name = name[1]
mobile = register_data[1]
user_mobile = int(mobile[1])
email = register_data[2]
user_email = email[1]
password = register_data[3]
user_password = password[1]
# kf.settings.app_id = 'f58c7bf9'
# kf.settings.app_key = '1b68e4a2b7e125ecb49a5729f5d3ed57'
kf.settings.app_id = 'ed6e261d'
kf.settings.app_key = 'bfe71f59834f765f8b215a06e9861434'
img_path = 'face.jpg'
print("hello")
enrolled_face = kf.enroll_face(file=img_path,
subject_id=str(user_mobile),
gallery_name='a-gallery')
print("hello w")
face_id = enrolled_face['face_id']
print(face_id)
status = enrolled_face['images'][0]['transaction']['status']
print(status)
if status == "success":
conn = mysql.connect(user='******',
password='******',
database='face',
host='localhost')
curs = conn.cursor()
#curs.execute("INSERT INTO registration1 (face_id) VALUES (%s)", (face_id));
#curs.execute('insert into registration1(face_id) values("%s")'%(face_id)' where contact='%(user_mobile))
curs.execute(
'insert into registration1(name,contact,email,password,face_id) values("%s","%d","%s","%s","%s")'
% (user_name, user_mobile, user_email, user_password, face_id))
conn.commit()
elif status == "failure":
return False
return render_template('login.html')
def test_returns_image_attributes_from_kairos_response(self):
response_dict = {
'images': [{
'transaction': {'face_id': 'new_face_id'},
'attributes': {
'gender': {'type': 'F', 'confidence': '80%'}
}
}]
}
responses.add(responses.POST, 'https://api.kairos.com/enroll', status=200,
body=json.dumps(response_dict))
_, attributes = kairos_face.enroll_face('sub_id', 'gallery', url='a_image_url.jpg')
expected_attributes = {
'gender': {
'type': 'F',
'confidence': 0.8
}
}
self.assertEqual(expected_attributes, attributes)
def enroll(facePhoto=None, subjectName=str(int(round(time.time() * 1000)))):
try:
#dict_responJSON = {}
dict_responJSON = kairos_face.enroll_face(file=facePhoto,
subject_id=subjectName,
gallery_name=face_gal_name)
"""
loop over images object, find transaction with status=success
"""
if dict_responJSON['images'][0]['transaction']['status'] == 'success':
dict_faces = {'cnt': 1}
else:
dict_faces = {'cnt': 0}
#dict_responJSON = dict_faces
except Exception, err:
if err.__class__ == kairos_face.exceptions.ServiceRequestError:
dict_responJSON = {
'error': err.response_msg['Errors'][0]['Message']
}
else:
dict_responJSON = {'error': str(err)}
def initKairos(self):
# clear current Kairos gallery
get_galleries_response = kairos_face.get_galleries_names_list()
if self.targetGallery in get_galleries_response['gallery_ids']:
kairos_face.remove_gallery(gallery_name=self.targetGallery)
# initialize gallery with preset images
if not os.path.exists('image/preset_image'):
raise Exception
if not os.path.exists('image/preset_face'):
os.mkdir('image/preset_face')
image_paths = glob.glob(os.path.join('image/preset_image/', "*"))
for image_path in image_paths:
image_path = image_path.replace("\\", "/") # Windows compatible
file_name = image_path.split("/")[2]
person_name = file_name.split(".")[0]
img = cv2.imread(image_path, 3)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = self.faceCascade.detectMultiScale(gray, 1.3, 5)
# zero or multiple faces detected
if len(faces) != 1:
print("Error: " + file_name + " " + str(len(faces)) +
" faces detected!\n")
# one face detected
else:
(x, y, w, h) = faces[0]
crop_img = img[y:y + h, x:x + w]
# write cropped face image
crop_img_path = 'image/preset_face/' + file_name
cv2.imwrite(crop_img_path, crop_img)
# enroll cropped face images (not preset images)
print("Enrolling: " + crop_img_path + " => " + person_name +
"\n")
enroll_face_response = kairos_face.enroll_face(
file='image/preset_face/' + file_name,
subject_id=person_name,
gallery_name=self.targetGallery)
#print(enroll_face_response)
face_id = enroll_face_response['face_id']
import matplotlib.pyplot as plt
import time
import os
#%matplotlib inline
kairos_face.settings.app_id = '9311364a'
kairos_face.settings.app_key = '21645ea39b84fccd009e59f1114ce9b8'
#putting in training data
for i in range(1, 7):
fname = 'kim' + str(i) + '.jpg'
print(fname)
if os.path.exists(fname) != True:
print('no such file')
kairos_face.enroll_face(file=fname,
subject_id='Kim Jong Un',
gallery_name='kju-gallery')
recognized_faces = kairos_face.recognize_face(file='kjursj.jpg',
gallery_name='kju-gallery')
image = face_recognition.load_image_file('kjursj.jpg')
for i in range(len(recognized_faces['images'])):
a_face = recognized_faces['images'][i]['transaction']
status = a_face['status']
top = a_face['topLeftY']
bottom = a_face['topLeftY'] + a_face['height']
left = a_face['topLeftX']
right = a_face['topLeftX'] + a_face['width']
face_image = image[top:bottom, left:right]
cont = 'y'
for frame in camera.capture_continuous(rawCapture,
format="bgr",
use_video_port=True):
image = frame.array
cv2.imwrite('image.png', image)
rawCapture.truncate(0)
try:
#Try to find current person in database, if not, enroll them
ans = kairos_face.recognize_face(file='image.png', gallery_name='test')
if 'Errors' in ans:
print ans['Errors'][0]['Message']
elif len(ans['images'][0]['candidates']) == 0:
print "Nobody found! Time to enroll!"
enr = kairos_face.enroll_face(
file='image.png',
subject_id=raw_input("What is your name: "),
gallery_name='test')
else:
print "Hello " + ans['images'][0]['transaction']['subject_id'] + "!"
except:
#Runs if gallery not found (database dumped)
print "Nobody found! Time to enroll!"
try:
enr = kairos_face.enroll_face(
file='image.png',
subject_id=raw_input("What is your name: "),
gallery_name='test')
print enr
except:
print "An error occurred. Please try again."
#Drop database to redo pictures and recognition
def test_throws_exception_when_both_file_and_url_are_passed(self):
with self.assertRaises(ValueError):
kairos_face.enroll_face('subject_id', 'gallery',
url='an_image_url.jpg', file='/path/tp/image.jpg')
def test_throws_exception_when_file_is_empty_string(self):
with self.assertRaises(ValueError):
kairos_face.enroll_face('subject_id', 'gallery', file='')
def test_throws_exception_when_app_key_is_not_set(self):
kairos_face.settings.app_key = None
with self.assertRaises(kairos_face.SettingsNotPresentException):
kairos_face.enroll_face('sub_id', 'gallery', url='a_image_path.jpg')
