| # 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() |
| its.caps.skip_unless(its.caps.compute_target_exposure(props) and |
| its.caps.per_frame_control(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 = cam.do_capture(req, 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: %.2fms, e_read: %.2fms, 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 = 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) |
| raw_cap = cam.do_capture(req, |
| {'format': 'rawStats', |
| 'gridWidth': aaw/IMG_STATS_GRID, |
| 'gridHeight': aah/IMG_STATS_GRID}) |
| 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() |
