def test_batch_fer_pil_image(self):
test_data = [
Image.open(os.path.normpath(os.path.join(DIR, "data/fear.png")))
]
response = fer(test_data, api_key=self.api_key)
self.assertTrue(isinstance(response, list))
self.assertTrue(isinstance(response[0], dict))
def test_bad_fer(self):
fer_set = set(['Angry', 'Sad', 'Neutral', 'Surprise', 'Fear', 'Happy'])
test_face = np.linspace(0,50,56*56).reshape(56,56).tolist()
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertEqual(fer_set, set(response.keys()))
def test_batch_fer_good_b64(self):
test_data = [
"iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAg5JREFUeNrEV4uNgzAMpegGyAgZgQ3KBscIjMAGx03QEdqbgG5AOwG3AWwAnSCXqLZkuUkwhfYsvaLm5xc7sZ1dIhdtUVjsLZRFTvp+LSaLq8UZ/s+KMSbZCcY5RV9E4QQKHG7QtgeCGv4PFt8WpzkCcztu3TiL0eJgkQmsVFn0MK+LzYkRKEGpG1GDyZdKRdaolhAoJewXnJsO1jtKCFDlChZAFxyJj2PnBRU20KZg7oMlOAENijpi8hwmGkKkZW2GzONtVLA/DxHAhTO2I7MCVBSQ6nGDlEBJDhyVYiUBHXBxzQm0wE4FzPYsGs856dA9SAAP2oENzFYqR6iAFQpHIAUzO/nxnOgthF/lM3w/3U8KYXTwxG/1IgIulF+wPQUXDMl75UoJZIHstRWpaGb8IGYqwBoKlG/lgpzoUEBoj50p8QtVrmHgaaXyC/H3BFC+e9kGFlCB0CtBF7FifQ8D9zjQQHj0pdOM3F1pUBoFKdxtqkMClScHJCSDlSxhHSNRT5K+FaZnHglrz+AGoxZLKNLYH6s3CkkuyJlp58wviZ4PuSCWDXl5hmjZtxcSCGbDUD3gK7EMOZBLCETrgVBF5K0lI5bIZ0wfrYh8NWHIAiNTPHpuTOKpCes1VTFaiNaFdGwPfdmaqlj6LmjJbgoSSfUW74K3voz+/W0oIeB7HWu2s+dfx3N+eLX8CTAAwUmKjK/dHS4AAAAASUVORK5CYII="
]
response = fer(test_data, api_key=self.api_key)
self.assertTrue(isinstance(response, list))
self.assertTrue(isinstance(response[0], dict))
def test_bad_fer(self):
fer_set = set(['Angry', 'Sad', 'Neutral', 'Surprise', 'Fear', 'Happy'])
test_face = os.path.normpath(os.path.join(DIR, "data/64by64.png"))
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertEqual(fer_set, set(response.keys()))
def test_good_fer(self):
fer_set = set(['Angry', 'Sad', 'Neutral', 'Surprise', 'Fear', 'Happy'])
test_face = np.random.rand(48, 48).tolist()
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertEqual(fer_set, set(response.keys()))
def test_int_array_fer(self):
fer_set = set(["Angry", "Sad", "Neutral", "Surprise", "Fear", "Happy"])
test_face = os.path.normpath(os.path.join(DIR, "data/48by48.png"))
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertEqual(fer_set, set(response.keys()))
def urlsToImages(imgUrls):
denom = len(imgUrls)
imgInfos = []
i = 0
for i, url in enumerate(imgUrls):
try:
imgInfo = indicoio.fer(url, detect=True)
imgInfos.append(imgInfo)
i += 1
print('%d / %d' % (i, denom))
except indicoio.utils.errors.IndicoError:
imgInfos.append({})
i += 1
print('%d / %d' % (i, denom))
except requests.exceptions.ConnectionError:
pass
print('Smoothening...')
imgs = list(map(Image.open, imgUrls))
smoothenFaces(imgInfos, imgs[0].size[0], imgs[0].size[1])
# with Image.open(imgUrls[0]) as first:
# smoothenFaces(imgInfos, first.size[0], first.size[1])
print('Adding emojis...')
for img, imgInfo in zip(imgs, imgInfos):
for faceInfo in imgInfo:
pasteEmojis_effectful(img, faceInfo)
return imgs
def test_happy_fer_pil(self):
test_face = Image.open(
os.path.normpath(os.path.join(DIR, "data/happy.png"))
).convert("L")
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response["Happy"] > 0.5)
def indico():
indicoio.config.api_key = "3e19af4454ebe0932333aff84913d88d"
gameCount = request.form["gameCount"]
emotion = request.form["emotion"]
photoUrl = request.form["photoUrl"]
result = {}
emotions = indicoio.fer(photoUrl, detect=True, sensitivity=0.4)[0]['emotions']
highestVals = {}
highestVals["happyVal"] = emotions["Happy"] + emotions["Neutral"]
highestVals["sadVal"] = emotions["Sad"] + emotions["Angry"]
highestVals["fearVal"] = emotions["Fear"] + emotions["Surprise"]
highestValsKey = max(highestVals.iteritems(), key=operator.itemgetter(1))[0]
highestKeys = max(emotions.iteritems(), key=operator.itemgetter(1))
for highestKey in highestKeys:
if (highestKey == "Happy" or highestKey == "Neutral" and highestValsKey == "happyVal") or (highestKey == "Sad" or highestKey == "Angry" and highestValsKey == "sadVal") or (highestKey == "Fear" or highestKey == "Surprise" and highestValsKey == "fearVal"):
if highestKey == emotion:
result["feedback"] = "You are correct!"
g.db.execute('insert into playthrough (score,playerid,gameid) values (?,?,?)',[1, session['userid'], session["game_id"]])
else:
result["feedback"] = "Not quite - try again!"
g.db.execute('insert into playthrough (score,playerid,gameid) values (?,?,?)',[0, session['userid'], session["game_id"]])
g.db.commit()
result[highestKey] = emotions[highestKey]
return jsonify(result)
highestKey = highestKeys[0]
result[highestKey] = emotions[highestKey]
return jsonify(result)
def gifUrlToFrames(url):
gif = Image.open(url)
imgs = []
i = 0
try:
while 1:
gif.seek(i)
frame = gif.copy()
w, h = frame.size
if w % 2: w -= 1
if h % 2: h -= 1
frame = frame.crop((0, 0, w, h)).convert('RGB')
try:
imgInfo = indicoio.fer(numpy.array(frame), detect=True)
[ pasteEmojis_effectful(frame, faceInfo) for faceInfo in imgInfo ]
imgs.append(frame)
i += 1
except indicoio.utils.errors.IndicoError:
imgs.append(frame)
i += 1
except requests.exceptions.ConnectionError:
pass
except EOFError:
return imgs
def test_good_fer(self):
fer_set = set(['Angry', 'Sad', 'Neutral', 'Surprise', 'Fear', 'Happy'])
test_face = np.random.rand(48,48).tolist()
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertEqual(fer_set, set(response.keys()))
def home(request):
image = HomeImages.objects.latest("datetime")
data = indicoio.fer(image.image.path)
data = max(data.items(), key=operator.itemgetter(1))[0]
image.emotion = data
image.save()
emotion_list = lookup_table[image.emotion]
total = len(emotion_list)
counter = 10
youtubVideos = []
for x in range(total):
if counter==0:
break
counter = counter -1
someData = emotion_list[random.randrange(0,total)]
while(someData==image.emotion):
someData = emotion_list[random.randrange(0,total)]
youtubVideos += youTubeSearch(someData, 3)
return render(request,"home/home.html",{"image":image,"youtubVideos":youtubVideos})
def gifUrlToFrames(url):
gif = Image.open(url)
imgs = []
i = 0
try:
while 1:
gif.seek(i)
frame = gif.copy()
w, h = frame.size
if w % 2: w -= 1
if h % 2: h -= 1
frame = frame.crop((0, 0, w, h)).convert('RGB')
try:
imgInfo = indicoio.fer(numpy.array(frame), detect=True)
[ pasteEmojis_effectful(frame, faceInfo) for faceInfo in imgInfo ]
imgs.append(frame)
i += 1
except indicoio.utils.errors.IndicoError:
imgs.append(frame)
i += 1
except requests.exceptions.ConnectionError:
pass
except EOFError:
return imgs
def urlsToImages(imgUrls):
denom = str(len(imgUrls))
imgInfos = []
i = 0
for i, url in enumerate(imgUrls):
try:
imgInfo = indicoio.fer(url, detect=True)
imgInfos.append(imgInfo)
i += 1
print(str(i) + '/' + denom)
except indicoio.utils.errors.IndicoError:
imgInfos.append({})
i += 1
print(str(i) + '/' + denom)
except requests.exceptions.ConnectionError:
pass
print('Smoothening...')
imgs = [ Image.open(url) for url in imgUrls ]
smoothenFaces(imgInfos, imgs[0].size[0], imgs[0].size[1])
print('Adding emojis...')
for img, imgInfo in zip(imgs, imgInfos):
for faceInfo in imgInfo:
pasteEmojis_effectful(img, faceInfo)
return imgs
def analyze_profile_pict(self):
try:
self.profile_pict_stats = Factor(
indicoio.fer(self.person.get_profile_pict()).items(),
'Profile picture emotions stats')
self.plotter.add_factor(self.profile_pict_stats)
except IndicoError:
raise PersonAnalyzerException(
'Error while fetching data from indicoio')
def findEmotion(thePath):
#finds the result of the emotions
theResult = indicoio.fer(thePath)
#finds the biggest emotion
maxI = max(
theResult,
key=theResult.get) # Just use 'min' instead of 'max' for minimum.
return maxI
def image_analysis(filepath):
indicoio.config.api_key = '428b1c1039ed8d8eaa886ee88044debd'
#print(indicoio.sentiment_hq('indico is so easy to use!'))
#filepath = "image0.jpg"
#Image.LOAD_TRUNCATED_IMAGES = True
#pixel_array = skimage.io.imread('filepath')
image = Image.open(filepath)
pixel_array = np.array(image)
#print (indicoio.fer(pixel_array))
return indicoio.fer(pixel_array)
def score(): list_of_acronyms = ['ANT', 'ARC', 'ART', 'AST', 'CBE', 'CHM', 'CEE', 'CLA', 'COM', 'COS', 'EAS', 'EEB', 'ECO', 'ELE', 'ENG', 'FRE', 'GEO', 'GER', 'HIS', 'MAT', 'MAE', 'MOL', 'MUS', 'NES', 'ORF', 'PHI', 'PHY', 'POL', 'PSY', 'REL', 'SLA', 'SOC', 'SPA', 'WWS']; dept_scores = []; for department in list_of_acronyms: directory = "/Users/Valerie/Documents/HackPrinceton/" + department; photos = [ f for f in listdir(directory) if isfile(join(directory,f)) ]; this_dept_scores = []; for photo in photos: path = directory + "/" + photo; pixel_array = skimage.io.imread(path).tolist() this_dept_scores.append(fer(pixel_array)); dept_scores.append(this_dept_scores);
def loadRecentPosts(self,recent_tags, api):
for tag in recent_tags:
#split the string returned to get users id
temp, new_id = tag.id.split('_')
user = api.user(new_id)
#gets amount of posts user has made
postCount = user.counts['media']
#gets the amount of followers the user has
followers = user.counts['followed_by']
#gets the amount of people the user is following
following = user.counts['follows']
#gets the number of likes of the post
likes = tag.like_count
print 'Post Number:', self.numPosts
print likes, 'likes'
print "Users Number of Posts:", postCount
print "Followers:", followers
print "Following:", following
# Checks each word in caption to see if it is positive, neutral or negative and
# puts it into a list then calculates its radius based on number of followers
if tag.caption is not None:
print(tag.caption.text)
sentiment = indicoio.sentiment_hq(tag.caption.text)
if sentiment >= 0.66:
self.positivePosts+=1
self.positiveY.append(sentiment*100)
self.positiveX.append(self.numPosts%(MAX_COUNT/3))
self.positiveRadius = self.calculateRadius(self.positiveRadius,followers)
elif sentiment >= 0.33:
self.neutralPosts+=1
self.neutralY.append(sentiment*100)
self.neutralX.append(self.numPosts%(MAX_COUNT/3))
self.neutralRadius = self.calculateRadius(self.neutralRadius,followers)
else:
self.negativePosts+=1
self.negativeY.append(sentiment*100)
self.negativeX.append(self.numPosts%(MAX_COUNT/3))
self.negativeRadius = self.calculateRadius(self.negativeRadius,followers)
#Use Indico API to calculate image sentiment
imageUrl = tag.images['low_resolution'].url
self.imageSentiment.append(indicoio.fer(imageUrl))
print # separate each post with a new line
self.numPosts+=1
def img_handler():
"""
- Grabs the binary data from the WebRTC still grab attached to POST
- WebRTC is intuitive--unicode or ASCII byte-encodings not-so-much.
Manipulates the unicode that Python gets from the POST request form dictionary
and turns it into the appropriate ASCII byte-encoding, which is then base-64-decoded,
and then piped into a random UUID-named .png file.
- As a hack, I used sshfs to mount the public_html directory of my UT Austin CS account address
into my working dir, and sent the new .png files into that folder, chmodding per upload.
- This renders the image into a resource that's easily accessible by APIs.
(Although this obviously won't scale, I only have 2 GB as an undergrad.)
- Finally, sends the URL via POST to the Microsoft Emotions API
- tl;dr I changed an image data-uri to a publicly available URL so it'd play better with some
ML libraries that didn't have native Python clients, but did have RESTful APIs.
"""
data = request.form.get('stillIn')
data = data[22:].encode('latin-1')
binary_data = a2b_base64(data)
session['uuid'] = str(uuid4())
fn = session['uuid'] + ".png"
with open('./models/mount/{}'.format(fn), 'wb') as fd:
fd.write(binary_data)
subprocess.call("chmod 755 ./models/mount/{}".format(fn),
shell=True)
resource = "http://cs.utexas.edu/~rainier/{}".format(fn)
print json.dumps({'url': resource})
# msft request
try:
msft_url = "https://api.projectoxford.ai/emotion/v1.0/recognize"
headers = {'Ocp-Apim-Subscription-Key': config['MSFT_EMOTION_KEY'],
'Content-Type': 'application/json'}
msft_req = requests.post(url=msft_url, data=json.dumps({'url': resource}), headers=headers)
print "msft {}".format(msft_req.json())
except:
flash('No face was detected!')
return redirect('/', messages=get_flashed_messages())
session['msft'] = msft_parse(msft_req.json())
# indicoio request
session['indico'] = indicoio.fer(resource)
# clarifai request
clarifai_api = ClarifaiApi()
clarifai_req = clarifai_api.tag_image_urls(resource)
session['clarifai'] = clarifai_parse(clarifai_req)
return redirect('/results')
def captureImage(request):
image = request.POST.get('image',None)
image = image.split('data:image/png;base64,')[1]
imageName = str(uuid.uuid1())+"out.png"
imagePath = MEDIA_ROOT+"/img/person/"+imageName
g = open(imagePath, "w")
g.write(base64.decodestring(image))
g.close()
img = HomeImages.objects.create()
img.image.save(imageName,File(open(imagePath, 'r')) )
data = indicoio.fer(imagePath)
data = max(data.items(), key=operator.itemgetter(1))[0]
img.emotion = data
img.save()
return HttpResponse("")
def score():
list_of_acronyms = [
'ANT', 'ARC', 'ART', 'AST', 'CBE', 'CHM', 'CEE', 'CLA', 'COM', 'COS',
'EAS', 'EEB', 'ECO', 'ELE', 'ENG', 'FRE', 'GEO', 'GER', 'HIS', 'MAT',
'MAE', 'MOL', 'MUS', 'NES', 'ORF', 'PHI', 'PHY', 'POL', 'PSY', 'REL',
'SLA', 'SOC', 'SPA', 'WWS'
]
dept_scores = []
for department in list_of_acronyms:
directory = "/Users/Valerie/Documents/HackPrinceton/" + department
photos = [f for f in listdir(directory) if isfile(join(directory, f))]
this_dept_scores = []
for photo in photos:
path = directory + "/" + photo
pixel_array = skimage.io.imread(path).tolist()
this_dept_scores.append(fer(pixel_array))
dept_scores.append(this_dept_scores)
def calculateSentimate(path): indicoio.config.api_key = '1329497cc5ba31312cd9f0777ffb4bad' #filepath='/home/suparna/Pictures/1.png' print(indicoio.fer(path)) return indicoio.fer(path)
def get_user_prediction(fit):
url = 'https://api.instagram.com/v1/users/self/?access_token=%s' % access_token
resp = requests.get(url=url)
data = resp.json()
followers = data['data']['counts']['followed_by']
follows = data['data']['counts']['follows']
day = 0
hour_float = 0.0
image_url = ''
new_post = []
count = 4
recent_media, next = api.user_recent_media(user_id='self', count=count)
for i, media in enumerate(recent_media):
new_post = []
image_url = media.get_standard_resolution_url()
day = media.created_time.weekday()
hour = str(media.created_time.hour) + ':' + str(media.created_time.minute)
likes = media.like_count
hashtags = len(media.tags)
if i == count-1:
captionSentiment = 0.5
if media.caption != None:
caption = media.caption.text.replace('\n', ' ').replace('\r', ' ').encode('utf-8')
captionSentiment = indicoio.sentiment(caption)
fer = indicoio.fer(image_url)
new_hour, minute = hour.split(':')
hour_float = new_hour
new_post.append(captionSentiment)
new_post.append(hour_float)
new_post.append(follows)
new_post.append(fer['Angry'])
new_post.append(hashtags)
new_post.append(day)
new_post.append(fer['Neutral'])
new_post.append(followers)
new_post.append(fer['Surprise'])
if follows > 0:
new_post.append(float(followers)/follows)
else:
new_post.append(float(followers))
new_post.append(fer['Sad'])
new_post.append(fer['Fear'])
new_post.append(fer['Happy'])
if followers > 0:
target = float(likes) / followers
else:
target = float(likes)
print image_url
print day
print hour
for i in xrange(0,24):
new_post[1] = i
predict = fit.predict(new_post)
prediction = predict[0]*followers
print "Predicted:", int(prediction)
print "Actual:", likes
print
print
def get_emotions(face):
# import numpy as np
# face = np.zeros((48, 48)).tolist()
emotions = fer(face, api_key=INDICO_API_KEY)
return emotions
def test_batch_fer_pil_image(self):
test_data = [Image.open(os.path.normpath(os.path.join(DIR, "data/fear.png")))]
response = fer(test_data, api_key=self.api_key)
self.assertTrue(isinstance(response, list))
self.assertTrue(isinstance(response[0], dict))
def test_batch_fer_good_b64(self):
test_data = ["iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAg5JREFUeNrEV4uNgzAMpegGyAgZgQ3KBscIjMAGx03QEdqbgG5AOwG3AWwAnSCXqLZkuUkwhfYsvaLm5xc7sZ1dIhdtUVjsLZRFTvp+LSaLq8UZ/s+KMSbZCcY5RV9E4QQKHG7QtgeCGv4PFt8WpzkCcztu3TiL0eJgkQmsVFn0MK+LzYkRKEGpG1GDyZdKRdaolhAoJewXnJsO1jtKCFDlChZAFxyJj2PnBRU20KZg7oMlOAENijpi8hwmGkKkZW2GzONtVLA/DxHAhTO2I7MCVBSQ6nGDlEBJDhyVYiUBHXBxzQm0wE4FzPYsGs856dA9SAAP2oENzFYqR6iAFQpHIAUzO/nxnOgthF/lM3w/3U8KYXTwxG/1IgIulF+wPQUXDMl75UoJZIHstRWpaGb8IGYqwBoKlG/lgpzoUEBoj50p8QtVrmHgaaXyC/H3BFC+e9kGFlCB0CtBF7FifQ8D9zjQQHj0pdOM3F1pUBoFKdxtqkMClScHJCSDlSxhHSNRT5K+FaZnHglrz+AGoxZLKNLYH6s3CkkuyJlp58wviZ4PuSCWDXl5hmjZtxcSCGbDUD3gK7EMOZBLCETrgVBF5K0lI5bIZ0wfrYh8NWHIAiNTPHpuTOKpCes1VTFaiNaFdGwPfdmaqlj6LmjJbgoSSfUW74K3voz+/W0oIeB7HWu2s+dfx3N+eLX8CTAAwUmKjK/dHS4AAAAASUVORK5CYII="]
response = fer(test_data, api_key=self.api_key)
self.assertTrue(isinstance(response, list))
self.assertTrue(isinstance(response[0], dict))
def get_test():
data = request.get_json(force=True)
sentiment = indicoio.fer(data['uri'])
human_response = evaluate_emotions(sentiment)
return jsonify({
'action': human_response })
text += "n"
text += " " + second_color["class"][:-5] + " " + second_word["class"]
if third_word["score"] != 0:
text += " or a"
if third_word["class"][0].lower() in "aeiou":
text += "n"
text += " " + third_word["class"]
text += "."
print "\nGenerated Text:", text
subprocess.call(["pico2wave", "-w", "description.wav",text])
subprocess.call(["aplay", "description.wav"])
#time.sleep(0.1)
else:
cam.capture("face.jpg")
#out = ino.image_recognition("image.jpg", top_n=5)
emotions = ino.fer("face.jpg")
#print(emotions)
emotes = sorted(emotions, key=lambda k: -emotions[k])[:3]
semotes = []
for emote in emotes:
if emote == "Sad": semotes.append("sad")
elif emote == "Fear": semotes.append("afraid")
elif emote == "Angry": semotes.append("mad")
elif emote == "Neutral": semotes.append("neutral")
elif emote == "Happy": semotes.append("happy")
else: semotes.append("surprised")
text = "The person is " + semotes[0] + ", " + semotes[1] + ", and " + semotes[2] + "."
print text
subprocess.call(["pico2wave", "-w", "emotion.wav",text])
subprocess.call(["aplay", "emotion.wav"])
def test_fear_fer(self):
test_face = self.load_image("../data/fear.png", as_grey=True)
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Fear'] > 0.25)
def test_batch_fer_filepath(self):
test_data = [os.path.normpath(os.path.join(DIR, "data/fear.png"))]
response = fer(test_data)
self.assertTrue(isinstance(response, list))
self.assertTrue(isinstance(response[0], dict))
def capture():
try:
global foo
img = cam.get_image()
pygame.image.save(img, "test" + str(foo) + ".jpg")
os.rename(
"/home/lx_user/Documents/programming/web/uanimate/test" +
str(foo) + ".jpg",
"/home/lx_user/Documents/programming/web/uanimate/test/test" +
str(foo) + ".jpg")
dict = indicoio.facial_localization(
"/home/lx_user/Documents/programming/web/uanimate/test/test" +
str(foo) + ".jpg")
image = pygame.image.load(
"/home/lx_user/Documents/programming/web/uanimate/test/test" +
str(foo) + ".jpg")
c_id = 0
#fear is disgust
happy = 0.0
sad = 0.0
angry = 0.0
fear = 0.0
surprise = 0.0
neutral = 0.0
total = 0.0
for i in range(0, int(len(dict))):
if (dict[i]['bottom_right_corner'][0] -
dict[i]['top_left_corner'][0] > 60000
or dict[i]['bottom_right_corner'][1] -
dict[i]['top_left_corner'][1] > 60000
or dict[i]['top_left_corner'][0] > 60000
or dict[i]['top_left_corner'][1] > 60000):
continue
crop_rect = (dict[i]['top_left_corner'][0],
dict[i]['top_left_corner'][1],
abs(dict[i]['bottom_right_corner'][0] -
dict[i]['top_left_corner'][0]),
abs(dict[i]['bottom_right_corner'][1] -
dict[i]['top_left_corner'][1]))
cropped = image.subsurface(crop_rect)
pygame.image.save(cropped,
str(foo) + "cropped" + str(c_id) + ".jpg")
# code for the emotion
results = indicoio.fer(str(foo) + "cropped" + str(c_id) + ".jpg")
# print(results)
if ('Happy' in results):
happy += results['Happy']
if ('Sad' in results):
sad += results['Sad']
if ('Angry' in results):
angry += results['Angry']
if ('Fear' in results):
fear += results['Fear']
if ('Surprise' in results):
surprise += results['Surprise']
total += (happy + sad + angry + fear + surprise)
os.rename(
"/home/lx_user/Documents/programming/web/uanimate/" +
str(foo) + "cropped" + str(c_id) + ".jpg",
"/home/lx_user/Documents/programming/web/uanimate/test/" +
str(foo) + "cropped" + str(c_id) + ".jpg")
c_id += 1
#open the file for reading:
file = open(
'/home/lx_user/Documents/programming/web/uanimate/results.txt',
'w')
#convert to string:
file.write(
str(happy) + " " + str(sad) + " " + str(angry) + " " + str(fear) +
" " + str(surprise) + " " + str(total))
file.close()
foo += 1
except (RuntimeError, TypeError, NameError, ValueError, IndexError,
IOError, KeyError):
print("wtf")
import indicoio indicoio.config.api_key = '1329497cc5ba31312cd9f0777ffb4bad' filepath=' print(indicoio.fer(filepath))
import indicoio
import sys
import os
indicoio.config.api_key = ''
source_image_directory = '../CK+'
source_image_lst = '../CK+/label_crop_face.lst'
result_file = 'ck+_indicoio.lst'
expression_list = ['Angry','Sad','Neutral','Surprise','Fear','Happy']
fo = open(result_file,'a')
fi = open(source_image_lst,'r')
lines = fi.readlines()
for l in lines:
arr = l.split()
file_path = os.path.join(source_image_directory,arr[0])
print 'doing '+file_path+' '+str(l)+' of '+str(len(lines))
result = indicoio.fer(file_path)
fo.write(file_path+'\n')
for e in expression_list:
fo.write(e+':'+str(result[e])+' ')
fo.write('\n')
fo.close()
import indicoio
import skimage.io
indicoio.config.api_key = "5daca1bb2437922364bfae1c7d733109"
import os
path = os.path.abspath('kevin.png')
pixel_array = skimage.io.imread(path).tolist()
from indicoio import fer, batch_fer, image_features
print(fer(pixel_array))
#print(image_features(pixel_array))
def test_happy_fer_pil(self):
test_face = Image.open(os.path.normpath(os.path.join(DIR, "data/happy.png"))).convert('L');
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Happy'] > 0.5)
def test_happy_fer(self):
test_face = self.load_image("../data/happy.png", as_grey=True)
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Happy'] > 0.5)
import indicoio
indicoio.config.api_key = 'your api key'
print indicoio.fer("/home/itamar/PycharmProjects/facedetection/im2.jpg")
def test_happy_fer(self):
test_face = os.path.normpath(os.path.join(DIR, "data/happy.png"))
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Happy'] > 0.5)
def test_fear_fer(self):
test_face = self.load_image("data/fear.png", as_grey=True)
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Fear'] > 0.25)
def test_fear_fer(self):
test_face = os.path.normpath(os.path.join(DIR, "data/fear.png"))
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Fear'] > 0.25)
def test_happy_fer(self):
test_face = self.load_image("data/happy.png", as_grey=True)
response = fer(test_face)
self.assertTrue(isinstance(response, dict))
self.assertTrue(response['Happy'] > 0.5)
def test_batch_fer(self):
test_data = [os.path.normpath(os.path.join(DIR, "data/48by48.png"))]
response = fer(test_data, api_key=self.api_key)
self.assertTrue(isinstance(response, list))
self.assertTrue(isinstance(response[0], dict))
collection.add_data([["text1", "label1"], ["text2", "label2"], ...])
# Training
collection.train()
# Telling Collection to block until ready
collection.wait()
# Done! Start analyzing text
collection.predict("indico is so easy to use!")
#images
import indicoio
indicoio.fer('https://IMAGE_URL')
Specifying Filepath
import indicoio
indicoio.fer('FILEPATH')
Formatting images using skimage
import skimage.io
import indicoio
pixel_array = skimage.io.imread('FILEPATH')
indicoio.fer(pixel_array)
Formatting images using PIL and numpy
def test_fer_detect(self):
test_data = os.path.normpath(os.path.join(DIR, "data/fear.png"))
response = fer(test_data, api_key=self.api_key, detect=True)
self.assertIsInstance(response, list)
self.assertEqual(len(response), 1)
self.assertIn("location", response[0])
pictureCount = 1
forwardCount = 0
text = 0
while True:
ret, frame = cam.read()
if not ret:
break
k = cv2.waitKey(1)
if k % 256 == 27:
# ESC pressed
print("Escape hit, closing...")
break
emotions = indicoio.fer(frame)
cv2.putText(frame, "Angry:" + str(emotions["Angry"]), (1, 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
cv2.putText(frame, "Sad:" + str(emotions["Sad"]), (1, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 127, 127), 2)
cv2.putText(frame, "Neutral:" + str(emotions["Neutral"]), (1, 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.putText(frame, "Surprise:" + str(emotions["Surprise"]), (1, 70),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (127, 127, 255), 2)
cv2.putText(frame, "Fear:" + str(emotions["Fear"]), (1, 90),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
cv2.putText(frame, "Happy:" + str(emotions["Happy"]), (1, 110),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (127, 0, 127), 2)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
def test_url_support(self):
test_url = "https://s3-us-west-2.amazonaws.com/indico-test-data/face.jpg"
response = fer(test_url, api_key=self.api_key)
self.assertTrue(isinstance(response, dict))
self.assertEqual(len(response.keys()), 6)
def test_url_support(self):
test_url = "https://s3-us-west-2.amazonaws.com/indico-test-data/face.jpg"
response = fer(test_url, api_key=self.api_key)
self.assertTrue(isinstance(response, dict))
self.assertEqual(len(response.keys()), 6)
