# Copyright 2022 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. """Ensure that FoV reduction with Preview Stabilization is within spec.""" import logging import math import os from mobly import test_runner import its_base_test import camera_properties_utils import image_fov_utils import image_processing_utils import its_session_utils import opencv_processing_utils import video_processing_utils _VIDEO_DURATION = 3 # seconds _MAX_STABILIZED_RADIUS_RATIO = 1.25 # An FOV reduction of 20% corresponds to an # increase in lengths of 25%. So the # stabilized circle's radius can be at most # 1.25 times that of an unstabilized circle _MAX_STABILIZED_RADIUS_ATOL = 1 # 1 pixel tol for radii inaccuracy _ROUNDESS_DELTA_THRESHOLD = 0.05 _MAX_CENTER_THRESHOLD_PERCENT = 0.075 _MAX_AREA = 1920 * 1440 # max mandatory preview stream resolution _MIN_CENTER_THRESHOLD_PERCENT = 0.03 _MIN_AREA = 176 * 144 # assume QCIF to be min preview size _KEY_FRAME_INDEX = -1 # last key frame _STABILIZED_SCALER_CROP_RTOL = 0.2 # 20% relative tolerance def _collect_data(cam, preview_size, stabilize): """Capture a preview video from the device. Captures camera preview frames from the passed device. Args: cam: camera object preview_size: str; preview resolution. ex. '1920x1080' stabilize: boolean; whether the preview should be stabilized or not Returns: recording object as described by cam.do_preview_recording """ recording_obj = cam.do_preview_recording(preview_size, _VIDEO_DURATION, stabilize) logging.debug('Recorded output path: %s', recording_obj['recordedOutputPath']) logging.debug('Tested quality: %s', recording_obj['quality']) return recording_obj def _point_distance(p1_x, p1_y, p2_x, p2_y): """Calculates the euclidean distance between two points. Args: p1_x: x coordinate of the first point p1_y: y coordinate of the first point p2_x: x coordinate of the second point p2_y: y coordinate of the second point Returns: Euclidean distance between two points """ return math.sqrt(pow(p1_x - p2_x, 2) + pow(p1_y - p2_y, 2)) def _calculate_center_offset_threshold(image_size): """Calculates appropriate center offset threshold. This function calculates a viable threshold that centers of two circles can be offset by for a given image size. The threshold percent is linearly interpolated between _MIN_CENTER_THRESHOLD_PERCENT and _MAX_CENTER_THRESHOLD_PERCENT according to the image size passed. Args: image_size: pair; size of the image for which threshold has to be calculated. ex. (1920, 1080) Returns: threshold value ratio between which the circle centers can differ """ img_area = image_size[0] * image_size[1] normalized_area = (img_area - _MIN_AREA) / (_MAX_AREA - _MIN_AREA) if normalized_area > 1 or normalized_area < 0: raise AssertionError(f'normalized area > 1 or < 0! ' f'image_size[0]: {image_size[0]}, ' f'image_size[1]: {image_size[1]}, ' f'normalized_area: {normalized_area}') # Threshold should be larger for images with smaller resolution normalized_threshold_percent = ((1 - normalized_area) * (_MAX_CENTER_THRESHOLD_PERCENT - _MIN_CENTER_THRESHOLD_PERCENT)) return normalized_threshold_percent + _MIN_CENTER_THRESHOLD_PERCENT class PreviewStabilizationFoVTest(its_base_test.ItsBaseTest): """Tests if stabilized preview FoV is within spec. The test captures two videos, one with preview stabilization on, and another with preview stabilization off. A representative frame is selected from each video, and analyzed to ensure that the FoV changes in the two videos are within spec. Specifically, the test checks for the following parameters with and without preview stabilization: - The circle roundness remains about constant - The center of the circle remains relatively stable - The size of circle changes no more that 20% i.e. the FOV changes at most 20% """ def test_preview_stabilization_fov(self): log_path = self.log_path 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) # Load scene. its_session_utils.load_scene(cam, props, self.scene, self.tablet, self.chart_distance) # Check skip condition first_api_level = its_session_utils.get_first_api_level(self.dut.serial) camera_properties_utils.skip_unless( first_api_level >= its_session_utils.ANDROID13_API_LEVEL, 'First API level should be {} or higher. Found {}.'.format( its_session_utils.ANDROID13_API_LEVEL, first_api_level)) # Log ffmpeg version being used video_processing_utils.log_ffmpeg_version() supported_stabilization_modes = props[ 'android.control.availableVideoStabilizationModes' ] camera_properties_utils.skip_unless( supported_stabilization_modes is not None and camera_properties_utils.STABILIZATION_MODE_PREVIEW in supported_stabilization_modes, 'Preview Stabilization not supported', ) # Raise error if not FRONT or REAR facing camera camera_properties_utils.check_front_or_rear_camera(props) # List of preview resolutions to test supported_preview_sizes = cam.get_supported_preview_sizes(self.camera_id) for size in video_processing_utils.LOW_RESOLUTION_SIZES: if size in supported_preview_sizes: supported_preview_sizes.remove(size) logging.debug('Supported preview resolutions: %s', supported_preview_sizes) test_failures = [] for preview_size in supported_preview_sizes: # recording with stabilization off ustab_rec_obj = _collect_data(cam, preview_size, False) # recording with stabilization on stab_rec_obj = _collect_data(cam, preview_size, True) # Grab the unstabilized video from DUT self.dut.adb.pull([ustab_rec_obj['recordedOutputPath'], log_path]) ustab_file_name = (ustab_rec_obj['recordedOutputPath'].split('/')[-1]) logging.debug('ustab_file_name: %s', ustab_file_name) # Grab the stabilized video from DUT self.dut.adb.pull([stab_rec_obj['recordedOutputPath'], log_path]) stab_file_name = (stab_rec_obj['recordedOutputPath'].split('/')[-1]) logging.debug('stab_file_name: %s', stab_file_name) # Get all frames from the videos ustab_file_list = video_processing_utils.extract_key_frames_from_video( log_path, ustab_file_name) logging.debug('Number of unstabilized iframes %d', len(ustab_file_list)) stab_file_list = video_processing_utils.extract_key_frames_from_video( log_path, stab_file_name) logging.debug('Number of stabilized iframes %d', len(stab_file_list)) # Extract last key frame to test from each video ustab_frame = os.path.join(log_path, video_processing_utils .get_key_frame_to_process(ustab_file_list)) logging.debug('unstabilized frame: %s', ustab_frame) stab_frame = os.path.join(log_path, video_processing_utils .get_key_frame_to_process(stab_file_list)) logging.debug('stabilized frame: %s', stab_frame) # Convert to numpy matrix for analysis ustab_np_image = image_processing_utils.convert_image_to_numpy_array( ustab_frame) logging.debug('unstabilized frame size: %s', ustab_np_image.shape) stab_np_image = image_processing_utils.convert_image_to_numpy_array( stab_frame) logging.debug('stabilized frame size: %s', stab_np_image.shape) image_size = stab_np_image.shape # Get circles to compare ustab_circle = opencv_processing_utils.find_circle( ustab_np_image, ustab_frame, image_fov_utils.CIRCLE_MIN_AREA, image_fov_utils.CIRCLE_COLOR) stab_circle = opencv_processing_utils.find_circle( stab_np_image, stab_frame, image_fov_utils.CIRCLE_MIN_AREA, image_fov_utils.CIRCLE_COLOR) failure_string = '' # Ensure the circles are equally round w/ and w/o stabilization ustab_roundness = ustab_circle['w'] / ustab_circle['h'] logging.debug('unstabilized roundness: %f', ustab_roundness) stab_roundness = stab_circle['w'] / stab_circle['h'] logging.debug('stabilized roundness: %f', stab_roundness) roundness_diff = abs(stab_roundness - ustab_roundness) if roundness_diff > _ROUNDESS_DELTA_THRESHOLD: failure_string += (f'Circle roundness changed too much: ' f'unstabilized ratio: {ustab_roundness}, ' f'stabilized ratio: {stab_roundness}, ' f'Expected ratio difference <= ' f'{_ROUNDESS_DELTA_THRESHOLD}, ' f'actual ratio difference: {roundness_diff}. ') # Distance between centers, x_offset and y_offset are relative to the # radius of the circle, so they're normalized. Not pixel values. unstab_center = (ustab_circle['x_offset'], ustab_circle['y_offset']) logging.debug('unstabilized center: %s', unstab_center) stab_center = (stab_circle['x_offset'], stab_circle['y_offset']) logging.debug('stabilized center: %s', stab_center) dist_centers = _point_distance(unstab_center[0], unstab_center[1], stab_center[0], stab_center[1]) center_offset_threshold = _calculate_center_offset_threshold(image_size) if dist_centers > center_offset_threshold: failure_string += (f'Circle moved too much: ' f'unstabilized center: (' f'{unstab_center[0]}, {unstab_center[1]}), ' f'stabilized center: ' f'({stab_center[0]}, {stab_center[1]}), ' f'expected distance < {center_offset_threshold}, ' f'actual_distance {dist_centers}. ') # ensure radius of stabilized frame is within 120% of radius within # unstabilized frame ustab_radius = ustab_circle['r'] logging.debug('unstabilized radius: %f', ustab_radius) stab_radius = stab_circle['r'] logging.debug('stabilized radius: %f', stab_radius) max_stab_radius = (ustab_radius * _MAX_STABILIZED_RADIUS_RATIO + _MAX_STABILIZED_RADIUS_ATOL) if stab_radius > max_stab_radius: failure_string += (f'Too much FoV reduction: ' f'unstabilized radius: {ustab_radius}, ' f'stabilized radius: {stab_radius}, ' f'expected max stabilized radius: ' f'{max_stab_radius}. ') # Calculate ratio of stabilized image's scaler crop region over # active array size and compare it against the ratio of stabilized # circle's radius over unstabilized circle if stab_radius > ustab_radius: stab_scaler_crop = (stab_rec_obj['captureMetadata'] [_KEY_FRAME_INDEX]['android.scaler.cropRegion']) scaler_crop_ratio = image_fov_utils.calc_scaler_crop_region_ratio( stab_scaler_crop, props) radius_ratio = ustab_radius / stab_radius if math.isclose(scaler_crop_ratio, radius_ratio, rel_tol=_STABILIZED_SCALER_CROP_RTOL): logging.debug('Crop region/active array: %f', scaler_crop_ratio) logging.debug('Stabilized/unstabilized circle: %f', radius_ratio) continue else: failure_string += (f'Too much FoV reduction: ' f'Crop region: {stab_scaler_crop}, ' f'Crop region ratio: {scaler_crop_ratio:.2%}, ' f'Circle ratio: {radius_ratio:.2%}, ' f'Tolerance: {_STABILIZED_SCALER_CROP_RTOL:.2%}') if failure_string: failure_string = f'{preview_size} fails FoV test. ' + failure_string test_failures.append(failure_string) if test_failures: raise AssertionError(test_failures) if __name__ == '__main__': test_runner.main()