159 lines
6.1 KiB
Python
159 lines
6.1 KiB
Python
# Copyright 2023 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.
|
|
"""Verify zoom ratio scales circle sizes correctly if settings override zoom is set."""
|
|
|
|
|
|
import logging
|
|
import os.path
|
|
|
|
import camera_properties_utils
|
|
import capture_request_utils
|
|
import image_processing_utils
|
|
import its_base_test
|
|
import its_session_utils
|
|
from mobly import test_runner
|
|
import numpy as np
|
|
import opencv_processing_utils
|
|
import zoom_capture_utils
|
|
|
|
|
|
_CIRCLE_COLOR = 0 # [0: black, 255: white]
|
|
_CIRCLE_AR_RTOL = 0.15 # contour width vs height (aspect ratio)
|
|
_CIRCLISH_RTOL = 0.05 # contour area vs ideal circle area pi*((w+h)/4)**2
|
|
_MIN_AREA_RATIO = 0.00015 # based on 2000/(4000x3000) pixels
|
|
_MIN_CIRCLE_PTS = 25
|
|
_NAME = os.path.splitext(os.path.basename(__file__))[0]
|
|
_NUM_STEPS = 10
|
|
_ZOOM_MIN_THRESH = 2.0
|
|
|
|
|
|
class LowLatencyZoomTest(its_base_test.ItsBaseTest):
|
|
"""Test the camera low latency zoom behavior.
|
|
|
|
On supported devices, set control.settingsOverride to ZOOM
|
|
to enable low latency zoom and do a burst capture of N frames.
|
|
|
|
Make sure that the zoomRatio in the capture result is reflected
|
|
in the captured image.
|
|
"""
|
|
|
|
def test_low_latency_zoom(self):
|
|
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)
|
|
camera_properties_utils.skip_unless(
|
|
camera_properties_utils.zoom_ratio_range(props) and
|
|
camera_properties_utils.low_latency_zoom(props))
|
|
|
|
# Load chart for scene
|
|
its_session_utils.load_scene(
|
|
cam, props, self.scene, self.tablet, self.chart_distance)
|
|
|
|
z_range = props['android.control.zoomRatioRange']
|
|
logging.debug('testing zoomRatioRange: %s', str(z_range))
|
|
debug = self.debug_mode
|
|
|
|
z_min, z_max = float(z_range[0]), float(z_range[1])
|
|
camera_properties_utils.skip_unless(z_max >= z_min * _ZOOM_MIN_THRESH)
|
|
z_list = np.arange(z_min, z_max, float(z_max - z_min) / (_NUM_STEPS - 1))
|
|
z_list = np.append(z_list, z_max)
|
|
|
|
# set TOLs based on camera and test rig params
|
|
if camera_properties_utils.logical_multi_camera(props):
|
|
test_tols, size = zoom_capture_utils.get_test_tols_and_cap_size(
|
|
cam, props, self.chart_distance, debug)
|
|
else:
|
|
test_tols = {}
|
|
fls = props['android.lens.info.availableFocalLengths']
|
|
for fl in fls:
|
|
test_tols[fl] = (zoom_capture_utils.RADIUS_RTOL,
|
|
zoom_capture_utils.OFFSET_RTOL)
|
|
yuv_size = capture_request_utils.get_largest_yuv_format(props)
|
|
size = [yuv_size['width'], yuv_size['height']]
|
|
logging.debug('capture size: %s', str(size))
|
|
logging.debug('test TOLs: %s', str(test_tols))
|
|
|
|
# do auto captures over zoom range and find circles with cv2
|
|
img_name_stem = f'{os.path.join(self.log_path, _NAME)}'
|
|
logging.debug('Using auto capture request')
|
|
cam.do_3a()
|
|
test_failed = False
|
|
fmt = 'yuv'
|
|
test_data = {}
|
|
reqs = []
|
|
req = capture_request_utils.auto_capture_request()
|
|
req['android.control.settingsOverride'] = camera_properties_utils.SETTINGS_OVERRIDE_ZOOM
|
|
for z in z_list:
|
|
logging.debug('zoom ratio: %.2f', z)
|
|
req_for_zoom = req.copy()
|
|
req_for_zoom['android.control.zoomRatio'] = z
|
|
reqs.append(req_for_zoom)
|
|
|
|
# take captures at different zoom ratios
|
|
caps = cam.do_capture(
|
|
reqs, {'format': fmt, 'width': size[0], 'height': size[1]})
|
|
|
|
# Check low latency zoom outputs match result metadata
|
|
for i, cap in enumerate(caps):
|
|
z_result = cap['metadata']['android.control.zoomRatio']
|
|
scaled_zoom = min(z_list[i], z_result)
|
|
logging.debug('zoom ratio in result: %.2f', z_result)
|
|
img = image_processing_utils.convert_capture_to_rgb_image(
|
|
cap, props=props)
|
|
img_name = f'{img_name_stem}_{fmt}_{i}_{round(z_result, 2)}.jpg'
|
|
image_processing_utils.write_image(img, img_name)
|
|
|
|
# determine radius tolerance of capture
|
|
cap_fl = cap['metadata']['android.lens.focalLength']
|
|
radius_tol, offset_tol = test_tols[cap_fl]
|
|
|
|
# convert [0, 1] image to [0, 255] and cast as uint8
|
|
img = image_processing_utils.convert_image_to_uint8(img)
|
|
|
|
# Find the center circle in img
|
|
try:
|
|
circle = opencv_processing_utils.find_center_circle(
|
|
img, img_name, _CIRCLE_COLOR, circle_ar_rtol=_CIRCLE_AR_RTOL,
|
|
circlish_rtol=_CIRCLISH_RTOL,
|
|
min_area=_MIN_AREA_RATIO*size[0]*size[1]*scaled_zoom*scaled_zoom,
|
|
min_circle_pts=_MIN_CIRCLE_PTS, debug=debug)
|
|
if opencv_processing_utils.is_circle_cropped(circle, size):
|
|
logging.debug('zoom %.2f is too large! Skip further captures',
|
|
z_result)
|
|
break
|
|
except AssertionError as e:
|
|
if z_result/z_list[0] >= zoom_capture_utils.ZOOM_MAX_THRESH:
|
|
break
|
|
else:
|
|
raise AssertionError(
|
|
'No circle detected for zoom ratio <= '
|
|
f'{zoom_capture_utils.ZOOM_MAX_THRESH}. '
|
|
'Take pictures according to instructions carefully!') from e
|
|
|
|
test_data[i] = {'z': z_result, 'circle': circle, 'r_tol': radius_tol,
|
|
'o_tol': offset_tol, 'fl': cap_fl}
|
|
|
|
if not zoom_capture_utils.verify_zoom_results(
|
|
test_data, size, z_max, z_min):
|
|
test_failed = True
|
|
|
|
if test_failed:
|
|
raise AssertionError(f'{_NAME} failed! Check test_log.DEBUG for errors')
|
|
|
|
if __name__ == '__main__':
|
|
test_runner.main()
|