Java Landmark.LEFT_EYE属性代码示例

private String getLandmarkKey( int landmarkType ) {
	switch( landmarkType ) {
		case Landmark.BOTTOM_MOUTH: return "mouth";
		case Landmark.LEFT_EYE: return "leftEye";
		case Landmark.RIGHT_EYE: return "rightEye";
		case Landmark.LEFT_EAR: return "leftEar";
		case Landmark.LEFT_EAR_TIP: return "leftEarTip";
		case Landmark.LEFT_CHEEK: return "leftCheek";
		case Landmark.LEFT_MOUTH: return "leftMouth";
		case Landmark.RIGHT_EAR: return "rightEar";
		case Landmark.RIGHT_EAR_TIP: return "rightEarTip";
		case Landmark.RIGHT_CHEEK: return "rightCheek";
		case Landmark.RIGHT_MOUTH: return "rightMouth";
		case Landmark.NOSE_BASE: return "noseBase";
		default: return null;
	}
}
 

@Override public void updateFace(Face face) {
  for (Landmark landmark : face.getLandmarks()) {
    switch (landmark.getType()) {
      case Landmark.LEFT_EYE:
        leftEye = landmark.getPosition();
        break;
      case Landmark.RIGHT_EYE:
        rightEye = landmark.getPosition();
        break;
    }
  }
  this.face = face;
}
 

private void locateEyes() {
    for (Landmark landmark : face.getLandmarks()) {
        switch (landmark.getType()) {
            case Landmark.LEFT_EYE:
                leftEye = landmark;
                break;
            case Landmark.RIGHT_EYE:
                rightEye = landmark;
                break;
            default: break;
        }
    }
}
 

public PhotoFace(Face face, Bitmap sourceBitmap, Size targetSize, boolean sideward) {
    List<Landmark> landmarks = face.getLandmarks();

    Point leftEyePoint = null;
    Point rightEyePoint = null;

    Point leftMouthPoint = null;
    Point rightMouthPoint = null;

    for (Landmark landmark : landmarks) {
        PointF point = landmark.getPosition();

        switch (landmark.getType()) {
            case Landmark.LEFT_EYE: {
                leftEyePoint = transposePoint(point, sourceBitmap, targetSize, sideward);
            }
            break;

            case Landmark.RIGHT_EYE: {
                rightEyePoint = transposePoint(point, sourceBitmap, targetSize, sideward);
            }
            break;

            case Landmark.LEFT_MOUTH: {
                leftMouthPoint = transposePoint(point, sourceBitmap, targetSize, sideward);
            }
            break;

            case Landmark.RIGHT_MOUTH: {
                rightMouthPoint = transposePoint(point, sourceBitmap, targetSize, sideward);
            }
            break;
        }
    }

    if (leftEyePoint != null && rightEyePoint != null) {
        eyesCenterPoint = new Point(0.5f * leftEyePoint.x + 0.5f * rightEyePoint.x,
                0.5f * leftEyePoint.y + 0.5f * rightEyePoint.y);
        eyesDistance = (float)Math.hypot(rightEyePoint.x - leftEyePoint.x, rightEyePoint.y - leftEyePoint.y);
        angle = (float)Math.toDegrees(Math.PI + Math.atan2(rightEyePoint.y - leftEyePoint.y, rightEyePoint.x - leftEyePoint.x));

        width = eyesDistance * 2.35f;

        float foreheadHeight = 0.8f * eyesDistance;
        float upAngle = (float)Math.toRadians(angle - 90);
        foreheadPoint = new Point(eyesCenterPoint.x + foreheadHeight * (float)Math.cos(upAngle),
                eyesCenterPoint.y + foreheadHeight * (float)Math.sin(upAngle));
    }

    if (leftMouthPoint != null && rightMouthPoint != null) {
        mouthPoint = new Point(0.5f * leftMouthPoint.x + 0.5f * rightMouthPoint.x,
                0.5f * leftMouthPoint.y + 0.5f * rightMouthPoint.y);

        float chinDepth = 0.7f * eyesDistance;
        float downAngle = (float)Math.toRadians(angle + 90);
        chinPoint = new Point(mouthPoint.x + chinDepth * (float)Math.cos(downAngle),
                mouthPoint.y + chinDepth * (float)Math.sin(downAngle));
    }
}
 

/**
     * Draws the face annotations for position on the supplied canvas.
     */
    @Override
    public void draw(Canvas canvas) {
        Face face = mFace;
        if (face == null) {
            return;
        }
        //send it back via a handler
//        Log.v(TAG, "Left eye is " + face.getIsLeftEyeOpenProbability());
//        Log.v(TAG, "Right eye is " + face.getIsRightEyeOpenProbability());
//        Log.v(TAG, "simle is " + face.getIsSmilingProbability());
        sendmessage("Smile: " + face.getIsSmilingProbability() +
                " Left: " + face.getIsLeftEyeOpenProbability() +
                " Right:" + face.getIsRightEyeOpenProbability());
        // Draws a circle at the position of the detected face, with the face's track id below.

        int xl = 10;  //how big the x is.
        //first get all the landmarks, we want the eyes and mounth, but there are more
        //https://developers.google.com/android/reference/com/google/android/gms/vision/face/Landmark
        List<Landmark> myLandmark = mFace.getLandmarks();
        float cx, cy;
        float lx = 0f, ly = 0f, mx = 0, my = 0, rx = 0, ry = 0;
        //loop through the list to find each one.  Note, they may not all be listed either.
        for (Landmark landmark : myLandmark) {

            if (landmark.getType() == Landmark.LEFT_EYE) {
                cx = translateX(landmark.getPosition().x);
                cy = translateY(landmark.getPosition().y);
                if (face.getIsLeftEyeOpenProbability() > .75) {  //open, so show circle
                    canvas.drawCircle(cx, cy, 10, GreenPaint);
                } else { //closed, so show x.
                    canvas.drawLine(cx - xl, cy - xl, cx + xl, cy + xl, RedPaint);
                    canvas.drawLine(cx - xl, cy + xl, cx + xl, cy - xl, RedPaint);
                }
            } else if (landmark.getType() == Landmark.RIGHT_EYE) {
                cx = translateX(landmark.getPosition().x);
                cy = translateY(landmark.getPosition().y);
                if (face.getIsRightEyeOpenProbability() > .75) {  //open, so show circle
                    canvas.drawCircle(cx, cy, 10, GreenPaint);
                } else { //closed, so show x.
                    canvas.drawLine(cx - xl, cy - xl, cx + xl, cy + xl, RedPaint);
                    canvas.drawLine(cx - xl, cy + xl, cx + xl, cy - xl, RedPaint);
                }
            } else if (landmark.getType() == Landmark.LEFT_MOUTH) {
                lx = translateX(landmark.getPosition().x);
                ly = translateY(landmark.getPosition().y);
                //canvas.drawCircle(lx, ly, 10, paint);
            } else if (landmark.getType() == Landmark.RIGHT_MOUTH) {
                rx = translateX(landmark.getPosition().x);
                ry = translateY(landmark.getPosition().y);
                //canvas.drawCircle(rx, ry, 10, paint);
            } else if (landmark.getType() == Landmark.BOTTOM_MOUTH) {
                mx = translateX(landmark.getPosition().x);
                my = translateY(landmark.getPosition().y);
                //canvas.drawCircle(mx, my, 10, paint);
            }
        }
        //now draw the mouth.   First check if all points exists
        if (lx > 0.0f && rx > 0.0f && mx > 0.0f) {
            //so first if one side of the mouth is higher, use that one.
            Log.v(TAG, "Drawing mouth");
            if (ly < ry)  //left side is higher
                ry = ly;
            else
                ly = ry;
            //okay, the points exist, so lets draw
            if (face.getIsSmilingProbability() > .75) { //smiling draw rec
                canvas.drawRect(lx, ly, rx, my, GreenPaint);
            } else {  //no smiling draw x
                canvas.drawLine(lx, ly, rx, my, RedPaint);
                canvas.drawLine(lx, my, rx, ry, RedPaint);
            }
        }

    }
 

/**
 * Draws the face annotations for position on the supplied canvas.
 */
@Override
public void draw(Canvas canvas) {
    Face face = mFace;
    if (face == null) {
        return;
    }

    Log.v(TAG, "Left eye is " + face.getIsLeftEyeOpenProbability());
    Log.v(TAG, "Right eye is " + face.getIsRightEyeOpenProbability());
    Log.v(TAG, "simle is " + face.getIsSmilingProbability());
    // Draws a circle at the position of the detected face, with the face's track id below.

    int xl = 10;  //how big the x is.
    //first get all the landmarks, we want the eyes and mounth, but there are more
    //https://developers.google.com/android/reference/com/google/android/gms/vision/face/Landmark
    List<Landmark> myLandmark = mFace.getLandmarks();
    float cx, cy;
    float lx = 0f, ly = 0f, mx = 0, my = 0, rx = 0, ry = 0;
    //loop through the list to find each one.  Note, they may not all be listed either.
    for (Landmark landmark : myLandmark) {

        if (landmark.getType() == Landmark.LEFT_EYE) {
            cx = translateX(landmark.getPosition().x);
            cy = translateY(landmark.getPosition().y);
            if (face.getIsLeftEyeOpenProbability() > .75) {  //open, so show circle
                canvas.drawCircle(cx, cy, 10, GreenPaint);
            } else { //closed, so show x.
                canvas.drawLine(cx - xl, cy - xl, cx + xl, cy + xl, RedPaint);
                canvas.drawLine(cx - xl, cy + xl, cx + xl, cy - xl, RedPaint);
            }
        } else if (landmark.getType() == Landmark.RIGHT_EYE) {
            cx = translateX(landmark.getPosition().x);
            cy = translateY(landmark.getPosition().y);
            if (face.getIsRightEyeOpenProbability() > .75) {  //open, so show circle
                canvas.drawCircle(cx, cy, 10, GreenPaint);
            } else { //closed, so show x.
                canvas.drawLine(cx - xl, cy - xl, cx + xl, cy + xl, RedPaint);
                canvas.drawLine(cx - xl, cy + xl, cx + xl, cy - xl, RedPaint);
            }
        } else if (landmark.getType() == Landmark.LEFT_MOUTH) {
            lx = translateX(landmark.getPosition().x);
            ly = translateY(landmark.getPosition().y);
            //canvas.drawCircle(lx, ly, 10, paint);
        } else if (landmark.getType() == Landmark.RIGHT_MOUTH) {
            rx = translateX(landmark.getPosition().x);
            ry = translateY(landmark.getPosition().y);
            //canvas.drawCircle(rx, ry, 10, paint);
        } else if (landmark.getType() == Landmark.BOTTOM_MOUTH) {
            mx = translateX(landmark.getPosition().x);
            my = translateY(landmark.getPosition().y);
            //canvas.drawCircle(mx, my, 10, paint);
        }
    }
    //now draw the mouth.   First check if all points exists
    if (lx > 0.0f && rx > 0.0f && mx > 0.0f) {
        //so first if one side of the mouth is higher, use that one.
        Log.v(TAG, "Drawing mouth");
        if (ly < ry)  //left side is higher
            ry = ly;
        else
            ly = ry;
        //okay, the points exist, so lets draw
        if (face.getIsSmilingProbability() > .75) { //smiling draw rec
            canvas.drawRect(lx, ly, rx, my, GreenPaint);
        } else {  //no smiling draw x
            canvas.drawLine(lx, ly, rx, my, RedPaint);
            canvas.drawLine(lx, my, rx, ry, RedPaint);
        }
    }

}
 

@Override
public void detect(
        SharedBufferHandle frameData, int width, int height, DetectResponse callback) {
    // The vision library will be downloaded the first time the API is used
    // on the device; this happens "fast", but it might have not completed,
    // bail in this case.
    if (!mFaceDetector.isOperational()) {
        Log.e(TAG, "FaceDetector is not operational");

        // Fallback to Android's FaceDetectionImpl.
        FaceDetectorOptions options = new FaceDetectorOptions();
        options.fastMode = mFastMode;
        options.maxDetectedFaces = mMaxFaces;
        FaceDetectionImpl detector = new FaceDetectionImpl(options);
        detector.detect(frameData, width, height, callback);
        return;
    }

    Frame frame = SharedBufferUtils.convertToFrame(frameData, width, height);
    if (frame == null) {
        Log.e(TAG, "Error converting SharedMemory to Frame");
        callback.call(new FaceDetectionResult[0]);
        return;
    }

    final SparseArray<Face> faces = mFaceDetector.detect(frame);

    FaceDetectionResult[] faceArray = new FaceDetectionResult[faces.size()];
    for (int i = 0; i < faces.size(); i++) {
        faceArray[i] = new FaceDetectionResult();
        final Face face = faces.valueAt(i);

        final PointF corner = face.getPosition();
        faceArray[i].boundingBox = new RectF();
        faceArray[i].boundingBox.x = corner.x;
        faceArray[i].boundingBox.y = corner.y;
        faceArray[i].boundingBox.width = face.getWidth();
        faceArray[i].boundingBox.height = face.getHeight();

        final List<Landmark> landmarks = face.getLandmarks();
        ArrayList<org.chromium.shape_detection.mojom.Landmark> mojoLandmarks =
                new ArrayList<org.chromium.shape_detection.mojom.Landmark>(landmarks.size());

        for (int j = 0; j < landmarks.size(); j++) {
            final Landmark landmark = landmarks.get(j);
            final int landmarkType = landmark.getType();
            if (landmarkType == Landmark.LEFT_EYE || landmarkType == Landmark.RIGHT_EYE
                    || landmarkType == Landmark.BOTTOM_MOUTH) {
                org.chromium.shape_detection.mojom.Landmark mojoLandmark =
                        new org.chromium.shape_detection.mojom.Landmark();
                mojoLandmark.location = new org.chromium.gfx.mojom.PointF();
                mojoLandmark.location.x = landmark.getPosition().x;
                mojoLandmark.location.y = landmark.getPosition().y;
                mojoLandmark.type = landmarkType == Landmark.BOTTOM_MOUTH ? LandmarkType.MOUTH
                                                                          : LandmarkType.EYE;
                mojoLandmarks.add(mojoLandmark);
            }
        }
        faceArray[i].landmarks = mojoLandmarks.toArray(
                new org.chromium.shape_detection.mojom.Landmark[mojoLandmarks.size()]);
    }
    callback.call(faceArray);
}