# Copyright 2014 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. """Verifies the DNG RAW model parameters are correct.""" import logging import math import os.path import matplotlib from matplotlib import pylab from mobly import test_runner import its_base_test import camera_properties_utils import capture_request_utils import image_processing_utils import its_session_utils BAYER_LIST = ['R', 'GR', 'GB', 'B'] NAME = os.path.splitext(os.path.basename(__file__))[0] NUM_STEPS = 4 PATCH_H = 0.02 # center 2% PATCH_W = 0.02 PATCH_X = 0.5 - PATCH_W/2 PATCH_Y = 0.5 - PATCH_H/2 VAR_ATOL_THRESH = 0.0012 # absolute variance delta threshold VAR_RTOL_THRESH = 0.2 # relative variance delta threshold class DngNoiseModelTest(its_base_test.ItsBaseTest): """Verify that the DNG raw model parameters are correct. Pass if the difference between expected and computed variances is small, defined as being within an absolute variance delta or relative variance delta of the expected variance, whichever is larger. This is to allow the test to pass in the presence of some randomness (since this test is measuring noise of a small patch) and some imperfect scene conditions (since ITS doesn't require a perfectly uniformly lit scene). """ def test_dng_noise_model(self): logging.debug('Starting %s', NAME) with its_session_utils.ItsSession( device_id=self.dut.serial, camera_id=self.camera_id, hidden_physical_id=self.hidden_physical_id) as cam: props = cam.get_camera_properties() props = cam.override_with_hidden_physical_camera_props(props) log_path = self.log_path # check SKIP conditions camera_properties_utils.skip_unless( camera_properties_utils.raw(props) and camera_properties_utils.raw16(props) and camera_properties_utils.manual_sensor(props) and camera_properties_utils.per_frame_control(props) and not camera_properties_utils.mono_camera(props)) # Load chart for scene its_session_utils.load_scene( cam, props, self.scene, self.tablet, self.chart_distance) # Expose for the scene with min sensitivity white_level = float(props['android.sensor.info.whiteLevel']) cfa_idxs = image_processing_utils.get_canonical_cfa_order(props) sens_min, _ = props['android.sensor.info.sensitivityRange'] sens_max_ana = props['android.sensor.maxAnalogSensitivity'] sens_step = (sens_max_ana - sens_min) // NUM_STEPS s_ae, e_ae, _, _, _ = cam.do_3a(get_results=True, do_af=False) # Focus at zero to intentionally blur the scene as much as possible. f_dist = 0.0 s_e_prod = s_ae * e_ae sensitivities = range(sens_min, sens_max_ana+1, sens_step) var_exp = [[], [], [], []] var_meas = [[], [], [], []] sens_valid = [] for sens in sensitivities: # Capture a raw frame with the desired sensitivity exp = int(s_e_prod / float(sens)) req = capture_request_utils.manual_capture_request(sens, exp, f_dist) cap = cam.do_capture(req, cam.CAP_RAW) planes = image_processing_utils.convert_capture_to_planes(cap, props) s_read = cap['metadata']['android.sensor.sensitivity'] logging.debug('iso_write: %d, iso_read: %d', sens, s_read) if self.debug_mode: img = image_processing_utils.convert_capture_to_rgb_image( cap, props=props) image_processing_utils.write_image( img, '%s_%d.jpg' % (os.path.join(log_path, NAME), sens)) # Test each raw color channel (R, GR, GB, B) noise_profile = cap['metadata']['android.sensor.noiseProfile'] assert len(noise_profile) == len(BAYER_LIST) for i, ch in enumerate(BAYER_LIST): # Get the noise model parameters for this channel of this shot. s, o = noise_profile[cfa_idxs[i]] # Use a very small patch to ensure gross uniformity (i.e. so # non-uniform lighting or vignetting doesn't affect the variance # calculation) black_level = image_processing_utils.get_black_level( i, props, cap['metadata']) level_range = white_level - black_level plane = image_processing_utils.get_image_patch( planes[i], PATCH_X, PATCH_Y, PATCH_W, PATCH_H) patch_raw = plane * white_level patch_norm = ((patch_raw - black_level) / level_range) # exit if distribution is clipped at 0, otherwise continue mean_img_ch = patch_norm.mean() var_model = s * mean_img_ch + o # This computation is suspicious because if the data were clipped, # the mean and standard deviation could be affected in a way that # affects this check. However, empirically, the mean and standard # deviation change more slowly than the clipping point itself does, # so the check remains correct even after the signal starts to clip. mean_minus_3sigma = mean_img_ch - math.sqrt(var_model) * 3 if mean_minus_3sigma < 0: e_msg = 'Pixel distribution crosses 0. Likely black level ' e_msg += 'over-clips. Linear model is not valid. ' e_msg += 'mean: %.3e, var: %.3e, u-3s: %.3e' % ( mean_img_ch, var_model, mean_minus_3sigma) assert mean_minus_3sigma < 0, e_msg else: var = image_processing_utils.compute_image_variances(patch_norm)[0] var_meas[i].append(var) var_exp[i].append(var_model) abs_diff = abs(var - var_model) logging.debug('%s mean: %.3f, var: %.3e, var_model: %.3e', ch, mean_img_ch, var, var_model) if var_model: rel_diff = abs_diff / var_model else: raise AssertionError(f'{ch} model variance = 0!') logging.debug('abs_diff: %.5f, rel_diff: %.3f', abs_diff, rel_diff) sens_valid.append(sens) # plot data and models pylab.figure(NAME) for i, ch in enumerate(BAYER_LIST): pylab.plot(sens_valid, var_exp[i], 'rgkb'[i], label=ch+' expected') pylab.plot(sens_valid, var_meas[i], 'rgkb'[i]+'.--', label=ch+' measured') pylab.title(NAME) pylab.xlabel('Sensitivity') pylab.ylabel('Center patch variance') pylab.ticklabel_format(axis='y', style='sci', scilimits=(-6, -6)) pylab.legend(loc=2) matplotlib.pyplot.savefig('%s_plot.png' % os.path.join(log_path, NAME)) # PASS/FAIL check for i, ch in enumerate(BAYER_LIST): var_diffs = [abs(var_meas[i][j] - var_exp[i][j]) for j in range(len(sens_valid))] logging.debug('%s variance diffs: %s', ch, str(var_diffs)) for j, diff in enumerate(var_diffs): thresh = max(VAR_ATOL_THRESH, VAR_RTOL_THRESH*var_exp[i][j]) assert diff <= thresh, 'var diff: %.5f, thresh: %.4f' % (diff, thresh) if __name__ == '__main__': test_runner.main()