# 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()