| # 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 android.scaler.cropRegion param works.""" |
| |
| |
| import logging |
| import os.path |
| |
| from mobly import test_runner |
| import numpy as np |
| |
| import its_base_test |
| import camera_properties_utils |
| import capture_request_utils |
| import image_processing_utils |
| import its_session_utils |
| import target_exposure_utils |
| |
| # 5 regions specified in normalized (x, y, w, h) coords. |
| CROP_REGIONS = [(0.0, 0.0, 0.5, 0.5), # top-left |
| (0.5, 0.0, 0.5, 0.5), # top-right |
| (0.0, 0.5, 0.5, 0.5), # bottom-left |
| (0.5, 0.5, 0.5, 0.5), # bottom-right |
| (0.25, 0.25, 0.5, 0.5)] # center |
| MIN_DIGITAL_ZOOM_THRESH = 2 |
| NAME = os.path.splitext(os.path.basename(__file__))[0] |
| |
| |
| class CropRegionsTest(its_base_test.ItsBaseTest): |
| """Test that crop regions works.""" |
| |
| def test_crop_regions(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.compute_target_exposure(props) and |
| camera_properties_utils.freeform_crop(props) and |
| camera_properties_utils.per_frame_control(props)) |
| |
| # Load chart for scene |
| its_session_utils.load_scene( |
| cam, props, self.scene, self.tablet, self.chart_distance) |
| |
| a = props['android.sensor.info.activeArraySize'] |
| ax, ay = a['left'], a['top'] |
| aw, ah = a['right'] - a['left'], a['bottom'] - a['top'] |
| e, s = target_exposure_utils.get_target_exposure_combos( |
| props, cam)['minSensitivity'] |
| logging.debug('Active sensor region (%d,%d %dx%d)', ax, ay, aw, ah) |
| |
| # Uses a 2x digital zoom. |
| max_digital_zoom = capture_request_utils.get_max_digital_zoom(props) |
| e_msg = 'Max digital zoom: %d, THRESH: %d' % (max_digital_zoom, |
| MIN_DIGITAL_ZOOM_THRESH) |
| assert max_digital_zoom >= MIN_DIGITAL_ZOOM_THRESH, e_msg |
| |
| # Capture a full frame. |
| req = capture_request_utils.manual_capture_request(s, e) |
| cap_full = cam.do_capture(req) |
| img_full = image_processing_utils.convert_capture_to_rgb_image(cap_full) |
| wfull, hfull = cap_full['width'], cap_full['height'] |
| image_processing_utils.write_image(img_full, '%s_full_%dx%d.jpg' % ( |
| os.path.join(log_path, NAME), wfull, hfull)) |
| |
| # Capture a burst of crop region frames. |
| # Note that each region is 1/2x1/2 of the full frame, and is digitally |
| # zoomed into the full size output image, so must be downscaled (below) |
| # by 2x when compared to a tile of the full image. |
| reqs = [] |
| for x, y, w, h in CROP_REGIONS: |
| req = capture_request_utils.manual_capture_request(s, e) |
| req['android.scaler.cropRegion'] = { |
| 'top': int(ah * y), |
| 'left': int(aw * x), |
| 'right': int(aw * (x + w)), |
| 'bottom': int(ah * (y + h))} |
| reqs.append(req) |
| caps_regions = cam.do_capture(reqs) |
| match_failed = False |
| for i, cap in enumerate(caps_regions): |
| a = cap['metadata']['android.scaler.cropRegion'] |
| ax, ay = a['left'], a['top'] |
| aw, ah = a['right'] - a['left'], a['bottom'] - a['top'] |
| |
| # Match this crop image against each of the five regions of |
| # the full image, to find the best match (which should be |
| # the region that corresponds to this crop image). |
| img_crop = image_processing_utils.convert_capture_to_rgb_image(cap) |
| img_crop = image_processing_utils.downscale_image(img_crop, 2) |
| image_processing_utils.write_image(img_crop, '%s_crop%d.jpg' % ( |
| os.path.join(log_path, NAME), i)) |
| min_diff = None |
| min_diff_region = None |
| for j, (x, y, w, h) in enumerate(CROP_REGIONS): |
| tile_full = image_processing_utils.get_image_patch( |
| img_full, x, y, w, h) |
| wtest = min(tile_full.shape[1], aw) |
| htest = min(tile_full.shape[0], ah) |
| tile_full = tile_full[0:htest:, 0:wtest:, ::] |
| tile_crop = img_crop[0:htest:, 0:wtest:, ::] |
| image_processing_utils.write_image( |
| tile_full, '%s_fullregion%d.jpg' % ( |
| os.path.join(log_path, NAME), j)) |
| diff = np.fabs(tile_full - tile_crop).mean() |
| if min_diff is None or diff < min_diff: |
| min_diff = diff |
| min_diff_region = j |
| if i != min_diff_region: |
| match_failed = True |
| logging.debug('Crop image %d (%d,%d %dx%d) best match with region %d', |
| i, ax, ay, aw, ah, min_diff_region) |
| |
| assert not match_failed |
| |
| if __name__ == '__main__': |
| test_runner.main() |
| |