blob: c266d144e3d12b59fa087fb5b0822ab52a12b728 [file] [log] [blame]
# 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
# --------------------------------------------------------------------------- #
# The Google Python style guide should be used for scripts: #
# #
# --------------------------------------------------------------------------- #
# The ITS modules that are in the pymodules/its/ directory. To see formatted
# docs, use the "pydoc" command:
# > pydoc its.image
import its.image
import its.device
import its.objects
# Standard Python modules.
import os.path
import pprint
import math
# Modules from the numpy, scipy, and matplotlib libraries. These are used for
# the image processing code, and images are represented as numpy arrays.
import pylab
import numpy
import matplotlib
import matplotlib.pyplot
# Each script has a "main" function.
def main():
# Each script has a string description of what it does. This is the first
# entry inside the main function.
"""Tutorial script to show how to use the ITS infrastructure.
# A convention in each script is to use the filename (without the extension)
# as the name of the test, when printing results to the screen or dumping
# files.
NAME = os.path.basename(__file__).split(".")[0]
# The standard way to open a session with a connected camera device. This
# creates a cam object which encapsulates the session and which is active
# within the scope of the "with" block; when the block exits, the camera
# session is closed.
with its.device.ItsSession() as cam:
# Get the static properties of the camera device. Returns a Python
# associative array object; print it to the console.
props = cam.get_camera_properties()
# Grab a YUV frame with manual exposure of sensitivity = 200, exposure
# duration = 50ms.
req = its.objects.manual_capture_request(200, 50*1000*1000)
cap = cam.do_capture(req)
# Print the properties of the captured frame; width and height are
# integers, and the metadata is a Python associative array object.
print "Captured image width:", cap["width"]
print "Captured image height:", cap["height"]
# The captured image is YUV420. Convert to RGB, and save as a file.
rgbimg = its.image.convert_capture_to_rgb_image(cap)
its.image.write_image(rgbimg, "%s_rgb_1.jpg" % (NAME))
# Can also get the Y,U,V planes separately; save these to greyscale
# files.
yimg,uimg,vimg = its.image.convert_capture_to_planes(cap)
its.image.write_image(yimg, "%s_y_plane_1.jpg" % (NAME))
its.image.write_image(uimg, "%s_u_plane_1.jpg" % (NAME))
its.image.write_image(vimg, "%s_v_plane_1.jpg" % (NAME))
# Run 3A on the device. In this case, just use the entire image as the
# 3A region, and run each of AWB,AE,AF. Can also change the region and
# specify independently for each of AE,AWB,AF whether it should run.
# NOTE: This may fail, if the camera isn't pointed at a reasonable
# target scene. If it fails, the script will end. The logcat messages
# can be inspected to see the status of 3A running on the device.
# > adb logcat -s 'ItsService:v'
# If this keeps on failing, try also rebooting the device before
# running the test.
sens, exp, gains, xform, focus = cam.do_3a(get_results=True)
print "AE: sensitivity %d, exposure %dms" % (sens, exp/1000000.0)
print "AWB: gains", gains, "transform", xform
print "AF: distance", focus
# Grab a new manual frame, using the 3A values, and convert it to RGB
# and save it to a file too. Note that the "req" object is just a
# Python dictionary that is pre-populated by the its.objets module
# functions (in this case a default manual capture), and the key/value
# pairs in the object can be used to set any field of the capture
# request. Here, the AWB gains and transform (CCM) are being used.
# Note that the CCM transform is in a rational format in capture
# requests, meaning it is an object with integer numerators and
# denominators. The 3A routine returns simple floats instead, however,
# so a conversion from float to rational must be performed.
req = its.objects.manual_capture_request(sens, exp)
xform_rat = its.objects.float_to_rational(xform)
req["android.colorCorrection.transform"] = xform_rat
req["android.colorCorrection.gains"] = gains
cap = cam.do_capture(req)
rgbimg = its.image.convert_capture_to_rgb_image(cap)
its.image.write_image(rgbimg, "%s_rgb_2.jpg" % (NAME))
# Print out the actual capture request object that was used.
# Images are numpy arrays. The dimensions are (h,w,3) when indexing,
# in the case of RGB images. Greyscale images are (h,w,1). Pixels are
# generally float32 values in the [0,1] range, however some of the
# helper functions in its.image deal with the packed YUV420 and other
# formats of images that come from the device (and convert them to
# float32).
# Print the dimensions of the image, and the top-left pixel value,
# which is an array of 3 floats.
print "RGB image dimensions:", rgbimg.shape
print "RGB image top-left pixel:", rgbimg[0,0]
# Grab a center tile from the image; this returns a new image. Save
# this tile image. In this case, the tile is the middle 10% x 10%
# rectangle.
tile = its.image.get_image_patch(rgbimg, 0.45, 0.45, 0.1, 0.1)
its.image.write_image(tile, "%s_rgb_2_tile.jpg" % (NAME))
# Compute the mean values of the center tile image.
rgb_means = its.image.compute_image_means(tile)
print "RGB means:", rgb_means
# Apply a lookup table to the image, and save the new version. The LUT
# is basically a tonemap, and can be used to implement a gamma curve.
# In this case, the LUT is used to double the value of each pixel.
lut = numpy.array([2*i for i in xrange(65536)])
rgbimg_lut = its.image.apply_lut_to_image(rgbimg, lut)
its.image.write_image(rgbimg_lut, "%s_rgb_2_lut.jpg" % (NAME))
# Apply a 3x3 matrix to the image, and save the new version. The matrix
# is a numpy array, in row major order, and the pixel values are right-
# multiplied to it (when considered as column vectors). The example
# matrix here just boosts the blue channel by 10%.
mat = numpy.array([[1, 0, 0 ],
[0, 1, 0 ],
[0, 0, 1.1]])
rgbimg_mat = its.image.apply_matrix_to_image(rgbimg, mat)
its.image.write_image(rgbimg_mat, "%s_rgb_2_mat.jpg" % (NAME))
# Compute a histogram of the luma image, in 256 buckets.
yimg,_,_ = its.image.convert_capture_to_planes(cap)
hist,_ = numpy.histogram(yimg*255, 256, (0,256))
# Plot the histogram using matplotlib, and save as a PNG image.
pylab.plot(range(256), hist.tolist())
pylab.xlabel("Luma DN")
pylab.ylabel("Pixel count")
pylab.title("Histogram of luma channel of captured image")
matplotlib.pyplot.savefig("%s_histogram.png" % (NAME))
# Capture a frame to be returned as a JPEG. Load it as an RGB image,
# then save it back as a JPEG.
cap = cam.do_capture(req, cam.CAP_JPEG)
rgbimg = its.image.convert_capture_to_rgb_image(cap)
its.image.write_image(rgbimg, "%s_jpg.jpg" % (NAME))
r,g,b = its.image.convert_capture_to_planes(cap)
its.image.write_image(r, "%s_r.jpg" % (NAME))
# This is the standard boilerplate in each test that allows the script to both
# be executed directly and imported as a module.
if __name__ == '__main__':