a

554325746@qq.com

2019-12-25 603cb36a5123e46656b06a5deb8d7ac7ff81307f

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package com.alfeye.a1camera;
 
import android.graphics.Point;
import android.graphics.Rect;
import android.hardware.Camera;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * Camera1 人脸补光
 * <p>
 * Created by DELL on 2019/4/9.
 */
 
public class FaceBrightnessAdjustUtil {
    //默认 补光阈值
    private int threshold = 100;
    private Rect mRect;
    private boolean enabled = true;
 
    public FaceBrightnessAdjustUtil() {
    }
 
 
    /**
     * 设置 人脸补光 位移阈值
     *
     * @param threshold 补光区域位移 阈值。大于此阈值才进行补光
     */
    public void setFaceBrightnessAdjustThreshold(int threshold) {
        this.threshold = threshold;
    }
 
    /**
     * 使能 人脸补光
     *
     * @param enabled
     */
    public void setEnFaceBrightnessAdjust(boolean enabled) {
        this.enabled = enabled;
    }
 
    /**
     * 执行 自动补光
     *
     * @param camera        Camera1摄像头
     * @param previewWidth  预览宽度
     * @param previewHeight 预览高度
     * @param rect          补光区域
     * @param rotate270     旋转补光区域  （旋转为竖屏坐标）
     */
    public void runAutoFaceBrightnessAdjust(Camera camera, int previewWidth, int previewHeight, Rect rect, boolean rotate270) {
        if (camera != null && enabled) {
            try {
                Camera.Parameters parameters = camera.getParameters();
                List<Camera.Area> meteringAreas = new ArrayList<>();
                if (rect != null) {
                    if (rotate270) {
                        rect = rotateDeg270(rect, previewWidth, previewHeight);
                    }
                    Point pointLeftTop = rotateDeg90(previewWidth, previewHeight, rect.left, rect.top);
                    Point pointRightBottom = rotateDeg90(previewWidth, previewHeight, rect.right, rect.bottom);
 
                    int left = Math.min(pointRightBottom.x, pointLeftTop.x);
                    int top = Math.min(pointLeftTop.y, pointRightBottom.y);
                    int right = Math.max(pointRightBottom.x, pointLeftTop.x);
                    int bottom = Math.max(pointLeftTop.y, pointRightBottom.y);
 
                    Rect aRect = new Rect(left, top, right, bottom);
                    meteringAreas.add(new Camera.Area(aRect, 800));
 
                    if (mRect != null) {
                        if (Math.abs(mRect.left - aRect.left) > threshold ||
                                Math.abs(mRect.top - aRect.top) > threshold ||
                                Math.abs(mRect.right - aRect.right) > threshold ||
                                Math.abs(mRect.bottom - aRect.bottom) > threshold) {
                            parameters.setMeteringAreas(meteringAreas);
                            parameters.setFocusAreas(meteringAreas);
                            camera.setParameters(parameters);
                            mRect = aRect;
                        }
                    } else {
                        parameters.setMeteringAreas(meteringAreas);
                        parameters.setFocusAreas(meteringAreas);
                        camera.setParameters(parameters);
                        mRect = aRect;
                    }
                } else {
                    Rect aRect = new Rect(0, 0, 1, 1);
                    meteringAreas.add(new Camera.Area(aRect, 800));
                    parameters.setMeteringAreas(meteringAreas);
                    parameters.setFocusAreas(meteringAreas);
                    camera.setParameters(parameters);
                    mRect = null;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
 
    private Point rotateDeg90(int previewWidth, int previewHeight, int x, int y) {
        Point point = new Point();
        int height = Math.max(previewWidth, previewHeight);
        int width = Math.min(previewWidth, previewHeight);
 
        point.x = (int) (1920 * (1 - (float) y / height));
        point.y = (int) (1080 * (1 - (float) x / width));
 
        if (point.x < 0) {
            point.x = 0;
        }
        if (point.y < 0) {
            point.y = 0;
        }
        return point;
    }
 
    /**
     * 矩形框的坐标旋转270度<br>
     * rotate the coordinate of rectangle with 270 degree
     *
     * @param rect   需要旋转的原始矩形框<br>
     *               the origin rectangle which need to rotate
     * @param width  图片的宽度<br>
     *               width of image
     * @param height 图片的高度<br>
     *               height of image
     * @return 旋转之后的矩形框<br>
     * rotated rectangle
     */
    private Rect rotateDeg270(Rect rect, int width, int height) {
        Rect newRect = new Rect();
        int left = rect.left;
        newRect.left = rect.top;
        newRect.top = width - rect.right;
        newRect.right = rect.bottom;
        newRect.bottom = width - left;
        return newRect;
    }
 
}