726 lines
30 KiB
Java
726 lines
30 KiB
Java
package com.affectiva.affdexme;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.BitmapFactory;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.Paint;
|
|
import android.graphics.PixelFormat;
|
|
import android.graphics.PointF;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.Rect;
|
|
import android.graphics.Typeface;
|
|
import android.os.Process;
|
|
import android.support.annotation.NonNull;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.Pair;
|
|
import android.view.SurfaceHolder;
|
|
import android.view.SurfaceView;
|
|
|
|
import com.affectiva.android.affdex.sdk.detector.Face;
|
|
|
|
import java.io.FileNotFoundException;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* This class contains a SurfaceView and its own thread that draws to it.
|
|
* It is used to display the facial tracking dots over a user's face.
|
|
*/
|
|
public class DrawingView extends SurfaceView implements SurfaceHolder.Callback {
|
|
|
|
private final static String LOG_TAG = "AffdexMe";
|
|
private final float MARGIN = 4;
|
|
private Bitmap appearanceMarkerBitmap_genderMale_glassesOn;
|
|
private Bitmap appearanceMarkerBitmap_genderFemale_glassesOn;
|
|
private Bitmap appearanceMarkerBitmap_genderUnknown_glassesOn;
|
|
private Bitmap appearanceMarkerBitmap_genderUnknown_glassesOff;
|
|
private Bitmap appearanceMarkerBitmap_genderMale_glassesOff;
|
|
private Bitmap appearanceMarkerBitmap_genderFemale_glassesOff;
|
|
private Map<String, Bitmap> emojiMarkerBitmapToEmojiTypeMap;
|
|
private SurfaceHolder surfaceHolder;
|
|
private DrawingThread drawingThread; //DrawingThread object
|
|
private DrawingViewConfig drawingViewConfig;
|
|
|
|
//three constructors required of any custom view
|
|
public DrawingView(Context context) {
|
|
super(context);
|
|
initView();
|
|
}
|
|
|
|
public DrawingView(Context context, AttributeSet attrs) {
|
|
super(context, attrs);
|
|
initView();
|
|
}
|
|
|
|
public DrawingView(Context context, AttributeSet attrs, int defStyle) {
|
|
super(context, attrs, defStyle);
|
|
initView();
|
|
}
|
|
|
|
private static int getDrawable(@NonNull Context context, @NonNull String name) {
|
|
return context.getResources().getIdentifier(name, "drawable", context.getPackageName());
|
|
}
|
|
|
|
void initView() {
|
|
surfaceHolder = getHolder(); //The SurfaceHolder object will be used by the thread to request canvas to draw on SurfaceView
|
|
surfaceHolder.setFormat(PixelFormat.TRANSPARENT); //set to Transparent so this surfaceView does not obscure the one it is overlaying (the one displaying the camera).
|
|
surfaceHolder.addCallback(this); //become a Listener to the three events below that SurfaceView generates
|
|
|
|
drawingViewConfig = new DrawingViewConfig();
|
|
|
|
//Default values
|
|
Paint emotionLabelPaint = new Paint();
|
|
emotionLabelPaint.setColor(Color.parseColor("#ff8000")); //Orange
|
|
emotionLabelPaint.setStyle(Paint.Style.FILL);
|
|
emotionLabelPaint.setTextAlign(Paint.Align.CENTER);
|
|
emotionLabelPaint.setTextSize(48);
|
|
|
|
Paint emotionValuePaint = new Paint();
|
|
emotionValuePaint.setColor(Color.parseColor("#514a40")); //Grey
|
|
emotionValuePaint.setStyle(Paint.Style.FILL);
|
|
emotionValuePaint.setTextAlign(Paint.Align.CENTER);
|
|
emotionValuePaint.setTextSize(48);
|
|
|
|
Paint metricBarPaint = new Paint();
|
|
metricBarPaint.setColor(Color.GREEN);
|
|
metricBarPaint.setStyle(Paint.Style.FILL);
|
|
int metricBarWidth = 150;
|
|
|
|
//load and parse XML attributes
|
|
int[] emotionLabelAttrs = {
|
|
android.R.attr.textStyle, // 0
|
|
android.R.attr.textColor, // 1
|
|
android.R.attr.shadowColor, // 2
|
|
android.R.attr.shadowDy, // 3
|
|
android.R.attr.shadowRadius, // 4
|
|
android.R.attr.layout_weight, // 5
|
|
android.R.attr.textSize}; // 6
|
|
TypedArray a = getContext().obtainStyledAttributes(R.style.metricName, emotionLabelAttrs);
|
|
if (a != null) {
|
|
emotionLabelPaint.setColor(a.getColor(1, emotionLabelPaint.getColor()));
|
|
emotionLabelPaint.setShadowLayer(
|
|
a.getFloat(4, 1.0f),
|
|
a.getFloat(3, 2.0f), a.getFloat(3, 2.0f),
|
|
a.getColor(2, Color.BLACK));
|
|
emotionLabelPaint.setTextSize(a.getDimensionPixelSize(6, 48));
|
|
emotionLabelPaint.setFakeBoldText("bold".equalsIgnoreCase(a.getString(0)));
|
|
a.recycle();
|
|
}
|
|
|
|
int[] emotionValueAttrs = {
|
|
android.R.attr.textColor, // 0
|
|
android.R.attr.textSize, // 1
|
|
R.styleable.custom_attributes_metricBarLength}; // 2
|
|
a = getContext().obtainStyledAttributes(R.style.metricPct, emotionValueAttrs);
|
|
if (a != null) {
|
|
emotionValuePaint.setColor(a.getColor(0, emotionValuePaint.getColor()));
|
|
emotionValuePaint.setTextSize(a.getDimensionPixelSize(1, 36));
|
|
metricBarWidth = a.getDimensionPixelSize(2, 150);
|
|
a.recycle();
|
|
}
|
|
|
|
drawingViewConfig.setDominantEmotionLabelPaints(emotionLabelPaint, emotionValuePaint);
|
|
drawingViewConfig.setDominantEmotionMetricBarConfig(metricBarPaint, metricBarWidth);
|
|
drawingThread = new DrawingThread(surfaceHolder, drawingViewConfig);
|
|
|
|
//statically load the emoji bitmaps on-demand and cache
|
|
emojiMarkerBitmapToEmojiTypeMap = new HashMap<>();
|
|
}
|
|
|
|
public void setTypeface(Typeface face) {
|
|
drawingViewConfig.dominantEmotionLabelPaint.setTypeface(face);
|
|
drawingViewConfig.dominantEmotionValuePaint.setTypeface(face);
|
|
}
|
|
|
|
@Override
|
|
public void surfaceCreated(SurfaceHolder holder) {
|
|
if (drawingThread.isStopped()) {
|
|
drawingThread = new DrawingThread(surfaceHolder, drawingViewConfig);
|
|
}
|
|
drawingThread.start();
|
|
}
|
|
|
|
@Override
|
|
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
|
|
}
|
|
|
|
@Override
|
|
public void surfaceDestroyed(SurfaceHolder holder) {
|
|
//command thread to stop, and wait until it stops
|
|
boolean retry = true;
|
|
drawingThread.stopThread();
|
|
while (retry) {
|
|
try {
|
|
drawingThread.join();
|
|
retry = false;
|
|
} catch (InterruptedException e) {
|
|
Log.e(LOG_TAG, e.getMessage());
|
|
}
|
|
}
|
|
cleanup();
|
|
}
|
|
|
|
public boolean isDimensionsNeeded() {
|
|
return drawingViewConfig.isDimensionsNeeded;
|
|
}
|
|
|
|
public void invalidateDimensions() {
|
|
drawingViewConfig.isDimensionsNeeded = true;
|
|
}
|
|
|
|
public void updateViewDimensions(int surfaceViewWidth, int surfaceViewHeight, int imageWidth, int imageHeight) {
|
|
try {
|
|
drawingViewConfig.updateViewDimensions(surfaceViewWidth, surfaceViewHeight, imageWidth, imageHeight);
|
|
} catch (IllegalArgumentException e) {
|
|
Log.e(LOG_TAG, "Attempted to set a dimension with a negative value", e);
|
|
}
|
|
}
|
|
|
|
public void setThickness(int t) {
|
|
try {
|
|
drawingViewConfig.setDrawThickness(t);
|
|
drawingThread.setThickness(t);
|
|
} catch (IllegalArgumentException e) {
|
|
Log.e(LOG_TAG, "Attempted to set a thickness with a negative value", e);
|
|
}
|
|
}
|
|
|
|
public boolean getDrawPointsEnabled() {
|
|
return drawingViewConfig.isDrawPointsEnabled;
|
|
}
|
|
|
|
public void setDrawPointsEnabled(boolean b) {
|
|
drawingViewConfig.isDrawPointsEnabled = b;
|
|
}
|
|
|
|
public boolean getDrawAppearanceMarkersEnabled() {
|
|
return drawingViewConfig.isDrawAppearanceMarkersEnabled;
|
|
}
|
|
|
|
public void setDrawAppearanceMarkersEnabled(boolean b) {
|
|
drawingViewConfig.isDrawAppearanceMarkersEnabled = b;
|
|
}
|
|
|
|
public boolean getDrawEmojiMarkersEnabled() {
|
|
return drawingViewConfig.isDrawEmojiMarkersEnabled;
|
|
}
|
|
|
|
public void setDrawEmojiMarkersEnabled(boolean b) {
|
|
drawingViewConfig.isDrawEmojiMarkersEnabled = b;
|
|
}
|
|
|
|
public void updatePoints(List<Face> faces, boolean isPointsMirrored) {
|
|
drawingThread.updatePoints(faces, isPointsMirrored);
|
|
}
|
|
|
|
public void invalidatePoints() {
|
|
drawingThread.invalidatePoints();
|
|
}
|
|
|
|
/**
|
|
* To be called when this view element is potentially being destroyed
|
|
* I.E. when the Activity's onPause() gets called.
|
|
*/
|
|
public void cleanup() {
|
|
if (emojiMarkerBitmapToEmojiTypeMap != null) {
|
|
for (Bitmap bitmap : emojiMarkerBitmapToEmojiTypeMap.values()) {
|
|
bitmap.recycle();
|
|
}
|
|
emojiMarkerBitmapToEmojiTypeMap.clear();
|
|
}
|
|
|
|
if (appearanceMarkerBitmap_genderMale_glassesOn != null) {
|
|
appearanceMarkerBitmap_genderMale_glassesOn.recycle();
|
|
}
|
|
if (appearanceMarkerBitmap_genderFemale_glassesOn != null) {
|
|
appearanceMarkerBitmap_genderFemale_glassesOn.recycle();
|
|
}
|
|
if (appearanceMarkerBitmap_genderUnknown_glassesOn != null) {
|
|
appearanceMarkerBitmap_genderUnknown_glassesOn.recycle();
|
|
}
|
|
if (appearanceMarkerBitmap_genderUnknown_glassesOff != null) {
|
|
appearanceMarkerBitmap_genderUnknown_glassesOff.recycle();
|
|
}
|
|
if (appearanceMarkerBitmap_genderMale_glassesOff != null) {
|
|
appearanceMarkerBitmap_genderMale_glassesOff.recycle();
|
|
}
|
|
if (appearanceMarkerBitmap_genderFemale_glassesOff != null) {
|
|
appearanceMarkerBitmap_genderFemale_glassesOff.recycle();
|
|
}
|
|
}
|
|
|
|
class FacesSharer {
|
|
boolean isPointsMirrored;
|
|
List<Face> facesToDraw;
|
|
|
|
public FacesSharer() {
|
|
isPointsMirrored = false;
|
|
facesToDraw = new ArrayList<>();
|
|
}
|
|
}
|
|
|
|
//Inner Thread class
|
|
class DrawingThread extends Thread {
|
|
private final FacesSharer sharer;
|
|
private final SurfaceHolder mSurfaceHolder;
|
|
private Paint trackingPointsPaint;
|
|
private Paint boundingBoxPaint;
|
|
private Paint dominantEmotionScoreBarPaint;
|
|
private volatile boolean stopFlag = false; //boolean to indicate when thread has been told to stop
|
|
private DrawingViewConfig config;
|
|
|
|
public DrawingThread(SurfaceHolder surfaceHolder, DrawingViewConfig con) {
|
|
mSurfaceHolder = surfaceHolder;
|
|
|
|
//statically load the Appearance marker bitmaps so they only have to load once
|
|
appearanceMarkerBitmap_genderMale_glassesOn = ImageHelper.loadBitmapFromInternalStorage(getContext(), "male_glasses.png");
|
|
appearanceMarkerBitmap_genderMale_glassesOff = ImageHelper.loadBitmapFromInternalStorage(getContext(), "male_noglasses.png");
|
|
appearanceMarkerBitmap_genderFemale_glassesOn = ImageHelper.loadBitmapFromInternalStorage(getContext(), "female_glasses.png");
|
|
appearanceMarkerBitmap_genderFemale_glassesOff = ImageHelper.loadBitmapFromInternalStorage(getContext(), "female_noglasses.png");
|
|
appearanceMarkerBitmap_genderUnknown_glassesOn = ImageHelper.loadBitmapFromInternalStorage(getContext(), "unknown_glasses.png");
|
|
appearanceMarkerBitmap_genderUnknown_glassesOff = ImageHelper.loadBitmapFromInternalStorage(getContext(), "unknown_noglasses.png");
|
|
|
|
trackingPointsPaint = new Paint();
|
|
trackingPointsPaint.setColor(Color.WHITE);
|
|
boundingBoxPaint = new Paint();
|
|
boundingBoxPaint.setColor(Color.WHITE);
|
|
boundingBoxPaint.setStyle(Paint.Style.STROKE);
|
|
dominantEmotionScoreBarPaint = new Paint();
|
|
dominantEmotionScoreBarPaint.setColor(Color.GREEN);
|
|
dominantEmotionScoreBarPaint.setStyle(Paint.Style.STROKE);
|
|
|
|
config = con;
|
|
sharer = new FacesSharer();
|
|
|
|
setThickness(config.drawThickness);
|
|
}
|
|
|
|
void setValenceOfBoundingBox(float valence) {
|
|
//prepare the color of the bounding box using the valence score. Red for -100, White for 0, and Green for +100, with linear interpolation in between.
|
|
if (valence > 0) {
|
|
float colorScore = ((100f - valence) / 100f) * 255;
|
|
boundingBoxPaint.setColor(Color.rgb((int) colorScore, 255, (int) colorScore));
|
|
} else {
|
|
float colorScore = ((100f + valence) / 100f) * 255;
|
|
boundingBoxPaint.setColor(Color.rgb(255, (int) colorScore, (int) colorScore));
|
|
}
|
|
}
|
|
|
|
public void stopThread() {
|
|
stopFlag = true;
|
|
}
|
|
|
|
public boolean isStopped() {
|
|
return stopFlag;
|
|
}
|
|
|
|
//Updates thread with latest faces returned by the onImageResults() event.
|
|
public void updatePoints(List<Face> faces, boolean isPointsMirrored) {
|
|
synchronized (sharer) {
|
|
sharer.facesToDraw.clear();
|
|
if (faces != null) {
|
|
sharer.facesToDraw.addAll(faces);
|
|
}
|
|
sharer.isPointsMirrored = isPointsMirrored;
|
|
}
|
|
}
|
|
|
|
void setThickness(int thickness) {
|
|
boundingBoxPaint.setStrokeWidth(thickness);
|
|
}
|
|
|
|
//Inform thread face detection has stopped, so pending faces are no longer valid.
|
|
public void invalidatePoints() {
|
|
synchronized (sharer) {
|
|
sharer.facesToDraw.clear();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
|
|
|
|
while (!stopFlag) {
|
|
|
|
/**
|
|
* We use SurfaceHolder.lockCanvas() to get the canvas that draws to the SurfaceView.
|
|
* After we are done drawing, we let go of the canvas using SurfaceHolder.unlockCanvasAndPost()
|
|
* **/
|
|
Canvas c = null;
|
|
try {
|
|
c = mSurfaceHolder.lockCanvas();
|
|
|
|
if (c != null) {
|
|
synchronized (mSurfaceHolder) {
|
|
c.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR); //clear previous dots
|
|
draw(c);
|
|
}
|
|
}
|
|
} finally {
|
|
if (c != null) {
|
|
mSurfaceHolder.unlockCanvasAndPost(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
config = null; //nullify object to avoid memory leak
|
|
}
|
|
|
|
void draw(Canvas c) {
|
|
Face nextFaceToDraw;
|
|
boolean mirrorPoints;
|
|
boolean multiFaceMode;
|
|
int index = 0;
|
|
|
|
synchronized (sharer) {
|
|
mirrorPoints = sharer.isPointsMirrored;
|
|
multiFaceMode = sharer.facesToDraw.size() > 1;
|
|
|
|
if (sharer.facesToDraw.isEmpty()) {
|
|
nextFaceToDraw = null;
|
|
} else {
|
|
nextFaceToDraw = sharer.facesToDraw.get(index);
|
|
index++;
|
|
}
|
|
}
|
|
|
|
while (nextFaceToDraw != null) {
|
|
|
|
drawFaceAttributes(c, nextFaceToDraw, mirrorPoints, multiFaceMode);
|
|
|
|
synchronized (sharer) {
|
|
mirrorPoints = sharer.isPointsMirrored;
|
|
|
|
if (index < sharer.facesToDraw.size()) {
|
|
nextFaceToDraw = sharer.facesToDraw.get(index);
|
|
index++;
|
|
} else {
|
|
nextFaceToDraw = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void drawFaceAttributes(Canvas c, Face face, boolean mirrorPoints, boolean isMultiFaceMode) {
|
|
//Coordinates around which to draw bounding box.
|
|
//Default to an 'inverted' box, where the absolute max and min values of the surface view are inside-out
|
|
Rect boundingRect = new Rect(config.surfaceViewWidth, config.surfaceViewHeight, 0, 0);
|
|
|
|
for (PointF point : face.getFacePoints()) {
|
|
//transform from the camera coordinates to our screen coordinates
|
|
//The camera preview is displayed as a mirror, so X pts have to be mirrored back.
|
|
float x;
|
|
if (mirrorPoints) {
|
|
x = (config.imageWidth - point.x) * config.screenToImageRatio;
|
|
} else {
|
|
x = (point.x) * config.screenToImageRatio;
|
|
}
|
|
float y = (point.y) * config.screenToImageRatio;
|
|
|
|
//For some reason I needed to add each point twice to make sure that all the
|
|
//points get properly registered in the bounding box.
|
|
boundingRect.union(Math.round(x), Math.round(y));
|
|
boundingRect.union(Math.round(x), Math.round(y));
|
|
|
|
//Draw facial tracking dots.
|
|
if (config.isDrawPointsEnabled) {
|
|
c.drawCircle(x, y, config.drawThickness, trackingPointsPaint);
|
|
}
|
|
}
|
|
|
|
//Draw the bounding box.
|
|
if (config.isDrawPointsEnabled) {
|
|
drawBoundingBox(c, face, boundingRect);
|
|
}
|
|
|
|
float heightOffset = findNecessaryHeightOffset(boundingRect, face);
|
|
|
|
//Draw the Appearance markers (gender / glasses)
|
|
if (config.isDrawAppearanceMarkersEnabled) {
|
|
drawAppearanceMarkers(c, face, boundingRect, heightOffset);
|
|
}
|
|
|
|
//Draw the Emoji markers
|
|
if (config.isDrawEmojiMarkersEnabled) {
|
|
drawDominantEmoji(c, face, boundingRect, heightOffset);
|
|
}
|
|
|
|
//Only draw the dominant emotion bar in multiface mode
|
|
if (isMultiFaceMode) {
|
|
drawDominantEmotion(c, face, boundingRect);
|
|
}
|
|
}
|
|
|
|
private float findNecessaryHeightOffset(Rect boundingBox, Face face) {
|
|
Bitmap appearanceBitmap = getAppearanceBitmapForFace(face);
|
|
Bitmap emojiBitmap = getDominantEmojiBitmapForFace(face);
|
|
|
|
float appearanceBitmapHeight = (appearanceBitmap != null) ? appearanceBitmap.getHeight() : 0;
|
|
float emojiBitmapHeight = (emojiBitmap != null) ? emojiBitmap.getHeight() : 0;
|
|
float spacingBetween = (appearanceBitmapHeight > 0 && emojiBitmapHeight > 0) ? MARGIN : 0;
|
|
float totalHeightRequired = appearanceBitmapHeight + emojiBitmapHeight + spacingBetween;
|
|
|
|
float bitmapHeightOverflow = Math.max(totalHeightRequired - boundingBox.height(), 0);
|
|
|
|
return bitmapHeightOverflow / 2; // distribute the overflow evenly on both sides of the bounding box
|
|
}
|
|
|
|
private void drawBoundingBox(Canvas c, Face f, Rect boundingBox) {
|
|
setValenceOfBoundingBox(f.emotions.getValence());
|
|
c.drawRect(boundingBox.left,
|
|
boundingBox.top,
|
|
boundingBox.right,
|
|
boundingBox.bottom,
|
|
boundingBoxPaint);
|
|
}
|
|
|
|
private void drawAppearanceMarkers(Canvas c, Face f, Rect boundingBox, float offset) {
|
|
Bitmap bitmap = getAppearanceBitmapForFace(f);
|
|
if (bitmap != null) {
|
|
drawBitmapIfNotRecycled(c, bitmap, boundingBox.right + MARGIN, boundingBox.bottom - bitmap.getHeight() + offset);
|
|
}
|
|
}
|
|
|
|
private Bitmap getAppearanceBitmapForFace(Face f) {
|
|
Bitmap bitmap = null;
|
|
switch (f.appearance.getGender()) {
|
|
case MALE:
|
|
if (Face.GLASSES.YES.equals(f.appearance.getGlasses())) {
|
|
bitmap = appearanceMarkerBitmap_genderMale_glassesOn;
|
|
} else {
|
|
bitmap = appearanceMarkerBitmap_genderMale_glassesOff;
|
|
}
|
|
break;
|
|
case FEMALE:
|
|
if (Face.GLASSES.YES.equals(f.appearance.getGlasses())) {
|
|
bitmap = appearanceMarkerBitmap_genderFemale_glassesOn;
|
|
} else {
|
|
bitmap = appearanceMarkerBitmap_genderFemale_glassesOff;
|
|
}
|
|
break;
|
|
case UNKNOWN:
|
|
if (Face.GLASSES.YES.equals(f.appearance.getGlasses())) {
|
|
bitmap = appearanceMarkerBitmap_genderUnknown_glassesOn;
|
|
} else {
|
|
bitmap = appearanceMarkerBitmap_genderUnknown_glassesOff;
|
|
}
|
|
break;
|
|
default:
|
|
Log.e(LOG_TAG, "Unknown gender: " + f.appearance.getGender());
|
|
}
|
|
return bitmap;
|
|
}
|
|
|
|
private void drawBitmapIfNotRecycled(Canvas c, Bitmap b, float posX, float posY) {
|
|
if (!b.isRecycled()) {
|
|
c.drawBitmap(b, posX, posY, null);
|
|
}
|
|
}
|
|
|
|
private void drawDominantEmoji(Canvas c, Face f, Rect boundingBox, float offset) {
|
|
drawEmojiFromCache(c, f.emojis.getDominantEmoji().name(), boundingBox.right + MARGIN, boundingBox.top - offset);
|
|
}
|
|
|
|
private void drawDominantEmotion(Canvas c, Face f, Rect boundingBox) {
|
|
Pair<String, Float> dominantMetric = findDominantEmotion(f);
|
|
|
|
if (dominantMetric == null || dominantMetric.first.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
String emotionText = dominantMetric.first;
|
|
String emotionValue = Math.round(dominantMetric.second) + "%";
|
|
|
|
Rect emotionTextBounds = new Rect();
|
|
config.dominantEmotionLabelPaint.getTextBounds(emotionText, 0, emotionText.length(), emotionTextBounds);
|
|
|
|
Rect emotionValueBounds = new Rect();
|
|
config.dominantEmotionValuePaint.getTextBounds(emotionValue, 0, emotionValue.length(), emotionValueBounds);
|
|
|
|
float drawAtX = boundingBox.exactCenterX();
|
|
float drawAtY = boundingBox.bottom + MARGIN + emotionTextBounds.height();
|
|
c.drawText(emotionText, drawAtX, drawAtY, config.dominantEmotionLabelPaint);
|
|
|
|
//draws the colored bar that appears behind our score
|
|
drawAtY += MARGIN + emotionValueBounds.height();
|
|
int halfWidth = Math.round(config.metricBarWidth / 200.0f * dominantMetric.second);
|
|
c.drawRect(drawAtX - halfWidth, drawAtY - emotionValueBounds.height(), drawAtX + halfWidth, drawAtY, config.dominantEmotionMetricBarPaint);
|
|
|
|
//draws the score
|
|
c.drawText(emotionValue, drawAtX, drawAtY, config.dominantEmotionValuePaint);
|
|
}
|
|
|
|
private Pair<String, Float> findDominantEmotion(Face f) {
|
|
String dominantMetricName = "";
|
|
Float dominantMetricValue = 50.0f; // no emotion is dominant unless at least greater than this value
|
|
|
|
if (f.emotions.getAnger() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.ANGER);
|
|
dominantMetricValue = f.emotions.getAnger();
|
|
}
|
|
if (f.emotions.getContempt() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.CONTEMPT);
|
|
dominantMetricValue = f.emotions.getContempt();
|
|
}
|
|
if (f.emotions.getDisgust() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.DISGUST);
|
|
dominantMetricValue = f.emotions.getDisgust();
|
|
}
|
|
if (f.emotions.getFear() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.FEAR);
|
|
dominantMetricValue = f.emotions.getFear();
|
|
}
|
|
if (f.emotions.getJoy() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.JOY);
|
|
dominantMetricValue = f.emotions.getJoy();
|
|
}
|
|
if (f.emotions.getSadness() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.SADNESS);
|
|
dominantMetricValue = f.emotions.getSadness();
|
|
}
|
|
if (f.emotions.getSurprise() > dominantMetricValue) {
|
|
dominantMetricName = MetricsManager.getCapitalizedName(MetricsManager.Emotions.SURPRISE);
|
|
dominantMetricValue = f.emotions.getSurprise();
|
|
}
|
|
// Ignore VALENCE and ENGAGEMENT
|
|
|
|
if (dominantMetricName.isEmpty()) {
|
|
return null;
|
|
} else {
|
|
return new Pair<>(dominantMetricName, dominantMetricValue);
|
|
}
|
|
}
|
|
|
|
void drawEmojiFromCache(Canvas c, String emojiName, float markerPosX, float markerPosY) {
|
|
Bitmap emojiBitmap;
|
|
|
|
try {
|
|
emojiBitmap = getEmojiBitmapByName(emojiName);
|
|
} catch (FileNotFoundException e) {
|
|
Log.e(LOG_TAG, "Error, file not found!", e);
|
|
return;
|
|
}
|
|
|
|
if (emojiBitmap != null) {
|
|
c.drawBitmap(emojiBitmap, markerPosX, markerPosY, null);
|
|
}
|
|
}
|
|
|
|
private Bitmap getDominantEmojiBitmapForFace(Face f) {
|
|
try {
|
|
return getEmojiBitmapByName(f.emojis.getDominantEmoji().name());
|
|
} catch (FileNotFoundException e) {
|
|
Log.e(LOG_TAG, "Dominant emoji bitmap not available", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Bitmap getEmojiBitmapByName(String emojiName) throws FileNotFoundException {
|
|
// No bitmap necessary if emoji is unknown
|
|
if (emojiName.equals(Face.EMOJI.UNKNOWN.name())) {
|
|
return null;
|
|
}
|
|
|
|
String emojiResourceName = emojiName.trim().replace(' ', '_').toLowerCase(Locale.US).concat("_emoji");
|
|
String emojiFileName = emojiResourceName + ".png";
|
|
|
|
//Try to get the emoji from the cache
|
|
Bitmap desiredEmojiBitmap = emojiMarkerBitmapToEmojiTypeMap.get(emojiFileName);
|
|
|
|
if (desiredEmojiBitmap != null) {
|
|
//emoji bitmap found in the cache
|
|
return desiredEmojiBitmap;
|
|
}
|
|
|
|
//Cache miss, try and load the bitmap from disk
|
|
desiredEmojiBitmap = ImageHelper.loadBitmapFromInternalStorage(getContext(), emojiFileName);
|
|
|
|
if (desiredEmojiBitmap != null) {
|
|
//emoji bitmap found in the app storage
|
|
|
|
|
|
//Bitmap loaded, add to cache for subsequent use.
|
|
emojiMarkerBitmapToEmojiTypeMap.put(emojiFileName, desiredEmojiBitmap);
|
|
|
|
return desiredEmojiBitmap;
|
|
}
|
|
|
|
Log.d(LOG_TAG, "Emoji not found on disk: " + emojiFileName);
|
|
|
|
//Still unable to find the file, try to locate the emoji resource
|
|
final int resourceId = getDrawable(getContext(), emojiFileName);
|
|
|
|
if (resourceId == 0) {
|
|
//unrecognised emoji file name
|
|
throw new FileNotFoundException("Resource not found for file named: " + emojiFileName);
|
|
}
|
|
|
|
desiredEmojiBitmap = BitmapFactory.decodeResource(getResources(), resourceId);
|
|
|
|
if (desiredEmojiBitmap == null) {
|
|
//still unable to load the resource from the file
|
|
throw new FileNotFoundException("Resource id [" + resourceId + "] but could not load bitmap: " + emojiFileName);
|
|
}
|
|
|
|
//Bitmap loaded, add to cache for subsequent use.
|
|
emojiMarkerBitmapToEmojiTypeMap.put(emojiFileName, desiredEmojiBitmap);
|
|
|
|
return desiredEmojiBitmap;
|
|
}
|
|
}
|
|
|
|
class DrawingViewConfig {
|
|
private int imageWidth = 1;
|
|
private int surfaceViewWidth = 0;
|
|
private int surfaceViewHeight = 0;
|
|
private float screenToImageRatio = 0;
|
|
private int drawThickness = 0;
|
|
private boolean isDrawPointsEnabled = true; //by default, have the drawing thread draw tracking dots
|
|
private boolean isDimensionsNeeded = true;
|
|
private boolean isDrawAppearanceMarkersEnabled = true; //by default, draw the appearance markers
|
|
private boolean isDrawEmojiMarkersEnabled = true; //by default, draw the dominant emoji markers
|
|
|
|
private Paint dominantEmotionLabelPaint;
|
|
private Paint dominantEmotionMetricBarPaint;
|
|
private Paint dominantEmotionValuePaint;
|
|
private int metricBarWidth;
|
|
|
|
public void setDominantEmotionLabelPaints(Paint labelPaint, Paint valuePaint) {
|
|
dominantEmotionLabelPaint = labelPaint;
|
|
dominantEmotionValuePaint = valuePaint;
|
|
}
|
|
|
|
public void setDominantEmotionMetricBarConfig(Paint metricBarPaint, int metricBarWidth) {
|
|
dominantEmotionMetricBarPaint = metricBarPaint;
|
|
this.metricBarWidth = metricBarWidth;
|
|
}
|
|
|
|
public void updateViewDimensions(int surfaceViewWidth, int surfaceViewHeight, int imageWidth, int imageHeight) {
|
|
if (surfaceViewWidth <= 0 || surfaceViewHeight <= 0 || imageWidth <= 0 || imageHeight <= 0) {
|
|
throw new IllegalArgumentException("All dimensions submitted to updateViewDimensions() must be positive");
|
|
}
|
|
this.imageWidth = imageWidth;
|
|
this.surfaceViewWidth = surfaceViewWidth;
|
|
this.surfaceViewHeight = surfaceViewHeight;
|
|
screenToImageRatio = (float) surfaceViewWidth / imageWidth;
|
|
isDimensionsNeeded = false;
|
|
}
|
|
|
|
public void setDrawThickness(int t) {
|
|
|
|
if (t <= 0) {
|
|
throw new IllegalArgumentException("Thickness must be positive.");
|
|
}
|
|
|
|
drawThickness = t;
|
|
}
|
|
}
|
|
}
|