# 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.path import its.caps import its.device import its.image import its.objects import its.target import matplotlib from matplotlib import pylab import numpy IMG_STATS_GRID = 9 # find used to find the center 11.11% NAME = os.path.basename(__file__).split('.')[0] THRESHOLD_MAX_OUTLIER_DIFF = 0.1 THRESHOLD_MIN_LEVEL = 0.1 THRESHOLD_MAX_LEVEL = 0.9 THRESHOLD_MAX_LEVEL_DIFF = 0.045 THRESHOLD_MAX_LEVEL_DIFF_WIDE_RANGE = 0.06 THRESH_ROUND_DOWN_GAIN = 0.1 THRESH_ROUND_DOWN_EXP = 0.03 THRESH_ROUND_DOWN_EXP0 = 1.00 # tol at 0ms exp; theoretical limit @ 4-line exp THRESH_EXP_KNEE = 6E6 # exposures less than knee have relaxed tol def get_raw_active_array_size(props): """Return the active array w, h from props.""" aaw = (props['android.sensor.info.preCorrectionActiveArraySize']['right'] - props['android.sensor.info.preCorrectionActiveArraySize']['left']) aah = (props['android.sensor.info.preCorrectionActiveArraySize']['bottom'] - props['android.sensor.info.preCorrectionActiveArraySize']['top']) return aaw, aah def main(): """Test that a constant exposure is seen as ISO and exposure time vary. Take a series of shots that have ISO and exposure time chosen to balance each other; result should be the same brightness, but over the sequence the images should get noisier. """ mults = [] r_means = [] g_means = [] b_means = [] raw_r_means = [] raw_gr_means = [] raw_gb_means = [] raw_b_means = [] threshold_max_level_diff = THRESHOLD_MAX_LEVEL_DIFF with its.device.ItsSession() as cam: props = cam.get_camera_properties() props = cam.override_with_hidden_physical_camera_props(props) its.caps.skip_unless(its.caps.compute_target_exposure(props)) sync_latency = its.caps.sync_latency(props) process_raw = its.caps.raw16(props) and its.caps.manual_sensor(props) debug = its.caps.debug_mode() largest_yuv = its.objects.get_largest_yuv_format(props) if debug: fmt = largest_yuv else: match_ar = (largest_yuv['width'], largest_yuv['height']) fmt = its.objects.get_smallest_yuv_format(props, match_ar=match_ar) e, s = its.target.get_target_exposure_combos(cam)['minSensitivity'] s_e_product = s*e expt_range = props['android.sensor.info.exposureTimeRange'] sens_range = props['android.sensor.info.sensitivityRange'] m = 1.0 while s*m < sens_range[1] and e/m > expt_range[0]: mults.append(m) s_test = round(s*m) e_test = s_e_product / s_test print 'Testing s:', s_test, 'e:', e_test req = its.objects.manual_capture_request( s_test, e_test, 0.0, True, props) cap = its.device.do_capture_with_latency( cam, req, sync_latency, fmt) s_res = cap['metadata']['android.sensor.sensitivity'] e_res = cap['metadata']['android.sensor.exposureTime'] # determine exposure tolerance based on exposure time if e_test >= THRESH_EXP_KNEE: thresh_round_down_exp = THRESH_ROUND_DOWN_EXP else: thresh_round_down_exp = ( THRESH_ROUND_DOWN_EXP + (THRESH_ROUND_DOWN_EXP0 - THRESH_ROUND_DOWN_EXP) * (THRESH_EXP_KNEE - e_test) / THRESH_EXP_KNEE) s_msg = 's_write: %d, s_read: %d, TOL=%.f%%' % ( s_test, s_res, THRESH_ROUND_DOWN_GAIN*100) e_msg = 'e_write: %.3fms, e_read: %.3fms, TOL=%.f%%' % ( e_test/1.0E6, e_res/1.0E6, thresh_round_down_exp*100) assert 0 <= s_test - s_res < s_test * THRESH_ROUND_DOWN_GAIN, s_msg assert 0 <= e_test - e_res < e_test * thresh_round_down_exp, e_msg s_e_product_res = s_res * e_res request_result_ratio = float(s_e_product) / s_e_product_res print 'Capture result s:', s_res, 'e:', e_res img = its.image.convert_capture_to_rgb_image(cap) its.image.write_image(img, '%s_mult=%3.2f.jpg' % (NAME, m)) tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1) rgb_means = its.image.compute_image_means(tile) # Adjust for the difference between request and result r_means.append(rgb_means[0] * request_result_ratio) g_means.append(rgb_means[1] * request_result_ratio) b_means.append(rgb_means[2] * request_result_ratio) # do same in RAW space if possible if process_raw and debug: aaw, aah = get_raw_active_array_size(props) fmt_raw = {'format': 'rawStats', 'gridWidth': aaw/IMG_STATS_GRID, 'gridHeight': aah/IMG_STATS_GRID} raw_cap = its.device.do_capture_with_latency( cam, req, sync_latency, fmt_raw) r, gr, gb, b = its.image.convert_capture_to_planes( raw_cap, props) raw_r_means.append(r[IMG_STATS_GRID/2, IMG_STATS_GRID/2] * request_result_ratio) raw_gr_means.append(gr[IMG_STATS_GRID/2, IMG_STATS_GRID/2] * request_result_ratio) raw_gb_means.append(gb[IMG_STATS_GRID/2, IMG_STATS_GRID/2] * request_result_ratio) raw_b_means.append(b[IMG_STATS_GRID/2, IMG_STATS_GRID/2] * request_result_ratio) # Test 3 steps per 2x gain m *= pow(2, 1.0 / 3) # Allow more threshold for devices with wider exposure range if m >= 64.0: threshold_max_level_diff = THRESHOLD_MAX_LEVEL_DIFF_WIDE_RANGE # Draw plots pylab.figure('rgb data') pylab.plot(mults, r_means, 'ro-') pylab.plot(mults, g_means, 'go-') pylab.plot(mults, b_means, 'bo-') pylab.title(NAME + 'RGB Data') pylab.xlabel('Gain Multiplier') pylab.ylabel('Normalized RGB Plane Avg') pylab.ylim([0, 1]) matplotlib.pyplot.savefig('%s_plot_means.png' % (NAME)) if process_raw and debug: pylab.figure('raw data') pylab.plot(mults, raw_r_means, 'ro-', label='R') pylab.plot(mults, raw_gr_means, 'go-', label='GR') pylab.plot(mults, raw_gb_means, 'ko-', label='GB') pylab.plot(mults, raw_b_means, 'bo-', label='B') pylab.title(NAME + 'RAW Data') pylab.xlabel('Gain Multiplier') pylab.ylabel('Normalized RAW Plane Avg') pylab.ylim([0, 1]) pylab.legend(numpoints=1) matplotlib.pyplot.savefig('%s_plot_raw_means.png' % (NAME)) # Check for linearity. Verify sample pixel mean values are close to each # other. Also ensure that the images aren't clamped to 0 or 1 # (which would make them look like flat lines). for chan in xrange(3): values = [r_means, g_means, b_means][chan] m, b = numpy.polyfit(mults, values, 1).tolist() max_val = max(values) min_val = min(values) max_diff = max_val - min_val print 'Channel %d line fit (y = mx+b): m = %f, b = %f' % (chan, m, b) print 'Channel max %f min %f diff %f' % (max_val, min_val, max_diff) assert max_diff < threshold_max_level_diff assert b > THRESHOLD_MIN_LEVEL and b < THRESHOLD_MAX_LEVEL for v in values: assert v > THRESHOLD_MIN_LEVEL and v < THRESHOLD_MAX_LEVEL assert abs(v - b) < THRESHOLD_MAX_OUTLIER_DIFF if process_raw and debug: for chan in xrange(4): values = [raw_r_means, raw_gr_means, raw_gb_means, raw_b_means][chan] m, b = numpy.polyfit(mults, values, 1).tolist() max_val = max(values) min_val = min(values) max_diff = max_val - min_val print 'Channel %d line fit (y = mx+b): m = %f, b = %f' % (chan, m, b) print 'Channel max %f min %f diff %f' % (max_val, min_val, max_diff) assert max_diff < threshold_max_level_diff assert b > THRESHOLD_MIN_LEVEL and b < THRESHOLD_MAX_LEVEL for v in values: assert v > THRESHOLD_MIN_LEVEL and v < THRESHOLD_MAX_LEVEL assert abs(v - b) < THRESHOLD_MAX_OUTLIER_DIFF if __name__ == '__main__': main()