| # Copyright 2016 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.path |
| |
| import its.caps |
| import its.device |
| import its.image |
| import its.objects |
| import its.target |
| |
| import matplotlib |
| from matplotlib import pylab |
| |
| NAME = os.path.basename(__file__).split('.')[0] |
| RATIO_THRESHOLD = 0.1 # Each raw image |
| # Waive the check if raw pixel value is below this level (signal too small |
| # that small black level error converts to huge error in percentage) |
| RAW_PIXEL_VAL_THRESHOLD = 0.03 |
| |
| |
| def main(): |
| """Check post RAW sensitivity boost. |
| |
| Capture a set of raw/yuv images with different |
| sensitivity/post RAW sensitivity boost combination |
| and check if the output pixel mean matches request settings |
| """ |
| |
| with its.device.ItsSession() as cam: |
| props = cam.get_camera_properties() |
| its.caps.skip_unless(its.caps.raw_output(props) and |
| its.caps.post_raw_sensitivity_boost(props) and |
| its.caps.compute_target_exposure(props) and |
| its.caps.per_frame_control(props) and |
| not its.caps.mono_camera(props)) |
| |
| w, h = its.objects.get_available_output_sizes( |
| 'yuv', props, (1920, 1080))[0] |
| |
| if its.caps.raw16(props): |
| raw_format = 'raw' |
| elif its.caps.raw10(props): |
| raw_format = 'raw10' |
| elif its.caps.raw12(props): |
| raw_format = 'raw12' |
| else: # should not reach here |
| raise its.error.Error('Cannot find available RAW output format') |
| |
| out_surfaces = [{'format': raw_format}, |
| {'format': 'yuv', 'width': w, 'height': h}] |
| |
| sens_min, sens_max = props['android.sensor.info.sensitivityRange'] |
| sens_boost_min, sens_boost_max = \ |
| props['android.control.postRawSensitivityBoostRange'] |
| |
| e_target, s_target = \ |
| its.target.get_target_exposure_combos(cam)['midSensitivity'] |
| |
| reqs = [] |
| settings = [] |
| s_boost = sens_boost_min |
| while s_boost <= sens_boost_max: |
| s_raw = int(round(s_target * 100.0 / s_boost)) |
| if s_raw < sens_min or s_raw > sens_max: |
| break |
| req = its.objects.manual_capture_request(s_raw, e_target) |
| req['android.control.postRawSensitivityBoost'] = s_boost |
| reqs.append(req) |
| settings.append((s_raw, s_boost)) |
| if s_boost == sens_boost_max: |
| break |
| s_boost *= 2 |
| # Always try to test maximum sensitivity boost value |
| if s_boost > sens_boost_max: |
| s_boost = sens_boost_max |
| |
| caps = cam.do_capture(reqs, out_surfaces) |
| |
| raw_rgb_means = [] |
| yuv_rgb_means = [] |
| raw_caps, yuv_caps = caps |
| if not isinstance(raw_caps, list): |
| raw_caps = [raw_caps] |
| if not isinstance(yuv_caps, list): |
| yuv_caps = [yuv_caps] |
| for i in xrange(len(reqs)): |
| (s, s_boost) = settings[i] |
| raw_cap = raw_caps[i] |
| yuv_cap = yuv_caps[i] |
| raw_rgb = its.image.convert_capture_to_rgb_image( |
| raw_cap, props=props) |
| yuv_rgb = its.image.convert_capture_to_rgb_image(yuv_cap) |
| raw_tile = its.image.get_image_patch(raw_rgb, 0.45, 0.45, 0.1, 0.1) |
| yuv_tile = its.image.get_image_patch(yuv_rgb, 0.45, 0.45, 0.1, 0.1) |
| raw_rgb_means.append(its.image.compute_image_means(raw_tile)) |
| yuv_rgb_means.append(its.image.compute_image_means(yuv_tile)) |
| its.image.write_image(raw_tile, '%s_raw_s=%04d_boost=%04d.jpg' % ( |
| NAME, s, s_boost)) |
| its.image.write_image(yuv_tile, '%s_yuv_s=%04d_boost=%04d.jpg' % ( |
| NAME, s, s_boost)) |
| print 's=%d, s_boost=%d: raw_means %s, yuv_means %s'%( |
| s, s_boost, raw_rgb_means[-1], yuv_rgb_means[-1]) |
| |
| xs = range(len(reqs)) |
| pylab.plot(xs, [rgb[0] for rgb in raw_rgb_means], '-ro') |
| pylab.plot(xs, [rgb[1] for rgb in raw_rgb_means], '-go') |
| pylab.plot(xs, [rgb[2] for rgb in raw_rgb_means], '-bo') |
| pylab.ylim([0, 1]) |
| name = '%s_raw_plot_means' % NAME |
| pylab.title(name) |
| pylab.xlabel('requests') |
| pylab.ylabel('RGB means') |
| matplotlib.pyplot.savefig('%s.png' % name) |
| pylab.clf() |
| pylab.plot(xs, [rgb[0] for rgb in yuv_rgb_means], '-ro') |
| pylab.plot(xs, [rgb[1] for rgb in yuv_rgb_means], '-go') |
| pylab.plot(xs, [rgb[2] for rgb in yuv_rgb_means], '-bo') |
| pylab.ylim([0, 1]) |
| name = '%s_yuv_plot_means' % NAME |
| pylab.title(name) |
| pylab.xlabel('requests') |
| pylab.ylabel('RGB means') |
| matplotlib.pyplot.savefig('%s.png' % name) |
| |
| rgb_str = ['R', 'G', 'B'] |
| # Test that raw means is about 2x brighter than next step |
| for step in range(1, len(reqs)): |
| (s_prev, _) = settings[step - 1] |
| (s, s_boost) = settings[step] |
| expect_raw_ratio = s_prev / float(s) |
| raw_thres_min = expect_raw_ratio * (1 - RATIO_THRESHOLD) |
| raw_thres_max = expect_raw_ratio * (1 + RATIO_THRESHOLD) |
| for rgb in range(3): |
| ratio = raw_rgb_means[step - 1][rgb] / raw_rgb_means[step][rgb] |
| print 'Step (%d,%d) %s channel: %f, %f, ratio %f,' % ( |
| step-1, step, rgb_str[rgb], |
| raw_rgb_means[step - 1][rgb], |
| raw_rgb_means[step][rgb], ratio), |
| print 'threshold_min %f, threshold_max %f' % ( |
| raw_thres_min, raw_thres_max) |
| if raw_rgb_means[step][rgb] <= RAW_PIXEL_VAL_THRESHOLD: |
| continue |
| assert raw_thres_min < ratio < raw_thres_max |
| |
| # Test that each yuv step is about the same bright as their mean |
| yuv_thres_min = 1 - RATIO_THRESHOLD |
| yuv_thres_max = 1 + RATIO_THRESHOLD |
| for rgb in range(3): |
| vals = [val[rgb] for val in yuv_rgb_means] |
| for step in range(len(reqs)): |
| if raw_rgb_means[step][rgb] <= RAW_PIXEL_VAL_THRESHOLD: |
| vals = vals[:step] |
| mean = sum(vals) / len(vals) |
| print '%s channel vals %s mean %f'%(rgb_str[rgb], vals, mean) |
| for step in range(len(vals)): |
| ratio = vals[step] / mean |
| assert yuv_thres_min < ratio < yuv_thres_max |
| |
| if __name__ == '__main__': |
| main() |
