| # Copyright 2016 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 matplotlib |
| matplotlib.use('Agg') |
| |
| import its.error |
| from matplotlib import pylab |
| import sys |
| from PIL import Image |
| import numpy |
| import math |
| import unittest |
| import cStringIO |
| import scipy.stats |
| import copy |
| import cv2 |
| import os |
| |
| def scale_img(img, scale=1.0): |
| """Scale and image based on a real number scale factor.""" |
| dim = (int(img.shape[1]*scale), int(img.shape[0]*scale)) |
| return cv2.resize(img.copy(), dim, interpolation=cv2.INTER_AREA) |
| |
| class Chart(object): |
| """Definition for chart object. |
| |
| Defines PNG reference file, chart size and distance, and scaling range. |
| """ |
| |
| def __init__(self, chart_file, height, distance, scale_start, scale_stop, |
| scale_step): |
| """Initial constructor for class. |
| |
| Args: |
| chart_file: str; absolute path to png file of chart |
| height: float; height in cm of displayed chart |
| distance: float; distance in cm from camera of displayed chart |
| scale_start: float; start value for scaling for chart search |
| scale_stop: float; stop value for scaling for chart search |
| scale_step: float; step value for scaling for chart search |
| """ |
| self._file = chart_file |
| self._height = height |
| self._distance = distance |
| self._scale_start = scale_start |
| self._scale_stop = scale_stop |
| self._scale_step = scale_step |
| |
| def _calc_scale_factors(self, cam, props, fmt, s, e, fd): |
| """Take an image with s, e, & fd to find the chart location. |
| |
| Args: |
| cam: An open device session. |
| props: Properties of cam |
| fmt: Image format for the capture |
| s: Sensitivity for the AF request as defined in |
| android.sensor.sensitivity |
| e: Exposure time for the AF request as defined in |
| android.sensor.exposureTime |
| fd: float; autofocus lens position |
| Returns: |
| template: numpy array; chart template for locator |
| img_3a: numpy array; RGB image for chart location |
| scale_factor: float; scaling factor for chart search |
| """ |
| req = its.objects.manual_capture_request(s, e) |
| req['android.lens.focusDistance'] = fd |
| cap_chart = its.image.stationary_lens_cap(cam, req, fmt) |
| img_3a = its.image.convert_capture_to_rgb_image(cap_chart, props) |
| img_3a = its.image.flip_mirror_img_per_argv(img_3a) |
| its.image.write_image(img_3a, 'af_scene.jpg') |
| template = cv2.imread(self._file, cv2.IMREAD_ANYDEPTH) |
| focal_l = cap_chart['metadata']['android.lens.focalLength'] |
| pixel_pitch = (props['android.sensor.info.physicalSize']['height'] / |
| img_3a.shape[0]) |
| print ' Chart distance: %.2fcm' % self._distance |
| print ' Chart height: %.2fcm' % self._height |
| print ' Focal length: %.2fmm' % focal_l |
| print ' Pixel pitch: %.2fum' % (pixel_pitch*1E3) |
| print ' Template height: %dpixels' % template.shape[0] |
| chart_pixel_h = self._height * focal_l / (self._distance * pixel_pitch) |
| scale_factor = template.shape[0] / chart_pixel_h |
| print 'Chart/image scale factor = %.2f' % scale_factor |
| return template, img_3a, scale_factor |
| |
| def locate(self, cam, props, fmt, s, e, fd): |
| """Find the chart in the image. |
| |
| Args: |
| cam: An open device session |
| props: Properties of cam |
| fmt: Image format for the capture |
| s: Sensitivity for the AF request as defined in |
| android.sensor.sensitivity |
| e: Exposure time for the AF request as defined in |
| android.sensor.exposureTime |
| fd: float; autofocus lens position |
| |
| Returns: |
| xnorm: float; [0, 1] left loc of chart in scene |
| ynorm: float; [0, 1] top loc of chart in scene |
| wnorm: float; [0, 1] width of chart in scene |
| hnorm: float; [0, 1] height of chart in scene |
| """ |
| chart, scene, s_factor = self._calc_scale_factors(cam, props, fmt, |
| s, e, fd) |
| scale_start = self._scale_start * s_factor |
| scale_stop = self._scale_stop * s_factor |
| scale_step = self._scale_step * s_factor |
| max_match = [] |
| # check for normalized image |
| if numpy.amax(scene) <= 1.0: |
| scene = (scene * 255.0).astype(numpy.uint8) |
| if len(scene.shape) == 2: |
| scene_gray = scene.copy() |
| elif len(scene.shape) == 3: |
| if scene.shape[2] == 1: |
| scene_gray = scene[:, :, 0] |
| else: |
| scene_gray = cv2.cvtColor(scene.copy(), cv2.COLOR_RGB2GRAY) |
| print 'Finding chart in scene...' |
| for scale in numpy.arange(scale_start, scale_stop, scale_step): |
| scene_scaled = scale_img(scene_gray, scale) |
| result = cv2.matchTemplate(scene_scaled, chart, cv2.TM_CCOEFF) |
| _, opt_val, _, top_left_scaled = cv2.minMaxLoc(result) |
| # print out scale and match |
| print ' scale factor: %.3f, opt val: %.f' % (scale, opt_val) |
| max_match.append((opt_val, top_left_scaled)) |
| |
| # determine if optimization results are valid |
| opt_values = [x[0] for x in max_match] |
| if 2.0*min(opt_values) > max(opt_values): |
| estring = ('Unable to find chart in scene!\n' |
| 'Check camera distance and self-reported ' |
| 'pixel pitch, focal length and hyperfocal distance.') |
| raise its.error.Error(estring) |
| # find max and draw bbox |
| match_index = max_match.index(max(max_match, key=lambda x: x[0])) |
| scale = scale_start + scale_step * match_index |
| print 'Optimum scale factor: %.3f' % scale |
| top_left_scaled = max_match[match_index][1] |
| h, w = chart.shape |
| bottom_right_scaled = (top_left_scaled[0] + w, top_left_scaled[1] + h) |
| top_left = (int(top_left_scaled[0]/scale), |
| int(top_left_scaled[1]/scale)) |
| bottom_right = (int(bottom_right_scaled[0]/scale), |
| int(bottom_right_scaled[1]/scale)) |
| wnorm = float((bottom_right[0]) - top_left[0]) / scene.shape[1] |
| hnorm = float((bottom_right[1]) - top_left[1]) / scene.shape[0] |
| xnorm = float(top_left[0]) / scene.shape[1] |
| ynorm = float(top_left[1]) / scene.shape[0] |
| return xnorm, ynorm, wnorm, hnorm |
| |
| |
| class __UnitTest(unittest.TestCase): |
| """Run a suite of unit tests on this module. |
| """ |
| |
| def test_compute_image_sharpness(self): |
| """Unit test for compute_img_sharpness. |
| |
| Test by using PNG of ISO12233 chart and blurring intentionally. |
| 'sharpness' should drop off by sqrt(2) for 2x blur of image. |
| |
| We do one level of blur as PNG image is not perfect. |
| """ |
| yuv_full_scale = 1023.0 |
| chart_file = os.path.join(os.environ['CAMERA_ITS_TOP'], 'pymodules', |
| 'its', 'test_images', 'ISO12233.png') |
| chart = cv2.imread(chart_file, cv2.IMREAD_ANYDEPTH) |
| white_level = numpy.amax(chart).astype(float) |
| sharpness = {} |
| for j in [2, 4, 8]: |
| blur = cv2.blur(chart, (j, j)) |
| blur = blur[:, :, numpy.newaxis] |
| sharpness[j] = (yuv_full_scale * |
| its.image.compute_image_sharpness(blur / white_level)) |
| self.assertTrue(numpy.isclose(sharpness[2]/sharpness[4], |
| numpy.sqrt(2), atol=0.1)) |
| self.assertTrue(numpy.isclose(sharpness[4]/sharpness[8], |
| numpy.sqrt(2), atol=0.1)) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
