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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
# Copyright 2013 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import os.path
import sys
import re
import json
import tempfile
import time
import unittest
import subprocess
import math
def int_to_rational(i):
"""Function to convert Python integers to Camera2 rationals.
Args:
i: Python integer or list of integers.
Returns:
Python dictionary or list of dictionaries representing the given int(s)
as rationals with denominator=1.
"""
if isinstance(i, list):
return [{"numerator":val, "denominator":1} for val in i]
else:
return {"numerator":i, "denominator":1}
def float_to_rational(f, denom=128):
"""Function to convert Python floats to Camera2 rationals.
Args:
f: Python float or list of floats.
denom: (Optonal) the denominator to use in the output rationals.
Returns:
Python dictionary or list of dictionaries representing the given
float(s) as rationals.
"""
if isinstance(f, list):
return [{"numerator":math.floor(val*denom+0.5), "denominator":denom}
for val in f]
else:
return {"numerator":math.floor(f*denom+0.5), "denominator":denom}
def rational_to_float(r):
"""Function to convert Camera2 rational objects to Python floats.
Args:
r: Rational or list of rationals, as Python dictionaries.
Returns:
Float or list of floats.
"""
if isinstance(r, list):
return [float(val["numerator"]) / float(val["denominator"])
for val in r]
else:
return float(r["numerator"]) / float(r["denominator"])
def manual_capture_request(sensitivity, exp_time, linear_tonemap=False):
"""Return a capture request with everything set to manual.
Uses identity/unit color correction, and the default tonemap curve.
Optionally, the tonemap can be specified as being linear.
Args:
sensitivity: The sensitivity value to populate the request with.
exp_time: The exposure time, in nanoseconds, to populate the request
with.
linear_tonemap: [Optional] whether a linear tonemap should be used
in this request.
Returns:
The default manual capture request, ready to be passed to the
its.device.do_capture function.
"""
req = {
"android.control.mode": 0,
"android.control.aeMode": 0,
"android.control.awbMode": 0,
"android.control.afMode": 0,
"android.control.effectMode": 0,
"android.sensor.frameDuration": 0,
"android.sensor.sensitivity": sensitivity,
"android.sensor.exposureTime": exp_time,
"android.colorCorrection.mode": 0,
"android.colorCorrection.transform":
int_to_rational([1,0,0, 0,1,0, 0,0,1]),
"android.colorCorrection.gains": [1,1,1,1],
"android.tonemap.mode": 1,
}
if linear_tonemap:
req["android.tonemap.mode"] = 0
req["android.tonemap.curveRed"] = [0.0,0.0, 1.0,1.0]
req["android.tonemap.curveGreen"] = [0.0,0.0, 1.0,1.0]
req["android.tonemap.curveBlue"] = [0.0,0.0, 1.0,1.0]
return req
def auto_capture_request():
"""Return a capture request with everything set to auto.
"""
return {
"android.control.mode": 1,
"android.control.aeMode": 1,
"android.control.awbMode": 1,
"android.control.afMode": 1,
"android.colorCorrection.mode": 1,
"android.tonemap.mode": 1,
}
def get_available_output_sizes(fmt, props):
"""Return a sorted list of available output sizes for a given format.
Args:
fmt: the output format, as a string in ["jpg", "yuv", "raw"].
props: the object returned from its.device.get_camera_properties().
Returns:
A sorted list of (w,h) tuples (sorted large-to-small).
"""
fmt_codes = {"raw":0x20, "yuv":0x23, "jpg":0x21, "jpeg":0x21}
configs = props['android.scaler.availableStreamConfigurations']
fmt_configs = [cfg for cfg in configs if cfg['format'] == fmt_codes[fmt]]
out_configs = [cfg for cfg in fmt_configs if cfg['input'] == False]
out_sizes = [(cfg['width'],cfg['height']) for cfg in out_configs]
out_sizes.sort(reverse=True)
return out_sizes
def get_fastest_manual_capture_settings(props):
"""Return a capture request and format spec for the fastest capture.
Args:
props: the object returned from its.device.get_camera_properties().
Returns:
Two values, the first is a capture request, and the second is an output
format specification, for the fastest possible (legal) capture that
can be performed on this device (with the smallest output size).
"""
fmt = "yuv"
size = get_available_output_sizes(fmt, props)[-1]
out_spec = {"format":fmt, "width":size[0], "height":size[1]}
s = min(props['android.sensor.info.sensitivityRange'])
e = min(props['android.sensor.info.exposureTimeRange'])
req = manual_capture_request(s,e)
return req, out_spec
class __UnitTest(unittest.TestCase):
"""Run a suite of unit tests on this module.
"""
def test_int_to_rational(self):
"""Unit test for int_to_rational.
"""
self.assertEqual(int_to_rational(10),
{"numerator":10,"denominator":1})
self.assertEqual(int_to_rational([1,2]),
[{"numerator":1,"denominator":1},
{"numerator":2,"denominator":1}])
def test_float_to_rational(self):
"""Unit test for float_to_rational.
"""
self.assertEqual(float_to_rational(0.5001, 64),
{"numerator":32, "denominator":64})
def test_rational_to_float(self):
"""Unit test for rational_to_float.
"""
self.assertTrue(
abs(rational_to_float({"numerator":32,"denominator":64})-0.5)
< 0.0001)
if __name__ == '__main__':
unittest.main()
|
