| # Copyright 2013 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 |
| import sys |
| from PIL import Image |
| import numpy |
| import math |
| import unittest |
| import cStringIO |
| import copy |
| import random |
| |
| DEFAULT_YUV_TO_RGB_CCM = numpy.matrix([ |
| [1.000, 0.000, 1.402], |
| [1.000, -0.344, -0.714], |
| [1.000, 1.772, 0.000]]) |
| |
| DEFAULT_YUV_OFFSETS = numpy.array([0, 128, 128]) |
| |
| DEFAULT_GAMMA_LUT = numpy.array( |
| [math.floor(65535 * math.pow(i/65535.0, 1/2.2) + 0.5) |
| for i in xrange(65536)]) |
| |
| DEFAULT_INVGAMMA_LUT = numpy.array( |
| [math.floor(65535 * math.pow(i/65535.0, 2.2) + 0.5) |
| for i in xrange(65536)]) |
| |
| MAX_LUT_SIZE = 65536 |
| |
| NUM_TRYS = 2 |
| NUM_FRAMES = 4 |
| |
| |
| def convert_capture_to_rgb_image(cap, |
| ccm_yuv_to_rgb=DEFAULT_YUV_TO_RGB_CCM, |
| yuv_off=DEFAULT_YUV_OFFSETS, |
| props=None): |
| """Convert a captured image object to a RGB image. |
| |
| Args: |
| cap: A capture object as returned by its.device.do_capture. |
| ccm_yuv_to_rgb: (Optional) the 3x3 CCM to convert from YUV to RGB. |
| yuv_off: (Optional) offsets to subtract from each of Y,U,V values. |
| props: (Optional) camera properties object (of static values); |
| required for processing raw images. |
| |
| Returns: |
| RGB float-3 image array, with pixel values in [0.0, 1.0]. |
| """ |
| w = cap["width"] |
| h = cap["height"] |
| if cap["format"] == "raw10": |
| assert(props is not None) |
| cap = unpack_raw10_capture(cap, props) |
| if cap["format"] == "raw12": |
| assert(props is not None) |
| cap = unpack_raw12_capture(cap, props) |
| if cap["format"] == "yuv": |
| y = cap["data"][0:w*h] |
| u = cap["data"][w*h:w*h*5/4] |
| v = cap["data"][w*h*5/4:w*h*6/4] |
| return convert_yuv420_planar_to_rgb_image(y, u, v, w, h) |
| elif cap["format"] == "jpeg": |
| return decompress_jpeg_to_rgb_image(cap["data"]) |
| elif cap["format"] == "raw" or cap["format"] == "rawStats": |
| assert(props is not None) |
| r,gr,gb,b = convert_capture_to_planes(cap, props) |
| return convert_raw_to_rgb_image(r,gr,gb,b, props, cap["metadata"]) |
| elif cap["format"] == "y8": |
| y = cap["data"][0:w*h] |
| return convert_y8_to_rgb_image(y, w, h) |
| else: |
| raise its.error.Error('Invalid format %s' % (cap["format"])) |
| |
| |
| def unpack_rawstats_capture(cap): |
| """Unpack a rawStats capture to the mean and variance images. |
| |
| Args: |
| cap: A capture object as returned by its.device.do_capture. |
| |
| Returns: |
| Tuple (mean_image var_image) of float-4 images, with non-normalized |
| pixel values computed from the RAW16 images on the device |
| """ |
| assert(cap["format"] == "rawStats") |
| w = cap["width"] |
| h = cap["height"] |
| img = numpy.ndarray(shape=(2*h*w*4,), dtype='<f', buffer=cap["data"]) |
| analysis_image = img.reshape(2,h,w,4) |
| mean_image = analysis_image[0,:,:,:].reshape(h,w,4) |
| var_image = analysis_image[1,:,:,:].reshape(h,w,4) |
| return mean_image, var_image |
| |
| |
| def unpack_raw10_capture(cap, props): |
| """Unpack a raw-10 capture to a raw-16 capture. |
| |
| Args: |
| cap: A raw-10 capture object. |
| props: Camera properties object. |
| |
| Returns: |
| New capture object with raw-16 data. |
| """ |
| # Data is packed as 4x10b pixels in 5 bytes, with the first 4 bytes holding |
| # the MSPs of the pixels, and the 5th byte holding 4x2b LSBs. |
| w,h = cap["width"], cap["height"] |
| if w % 4 != 0: |
| raise its.error.Error('Invalid raw-10 buffer width') |
| cap = copy.deepcopy(cap) |
| cap["data"] = unpack_raw10_image(cap["data"].reshape(h,w*5/4)) |
| cap["format"] = "raw" |
| return cap |
| |
| |
| def unpack_raw10_image(img): |
| """Unpack a raw-10 image to a raw-16 image. |
| |
| Output image will have the 10 LSBs filled in each 16b word, and the 6 MSBs |
| will be set to zero. |
| |
| Args: |
| img: A raw-10 image, as a uint8 numpy array. |
| |
| Returns: |
| Image as a uint16 numpy array, with all row padding stripped. |
| """ |
| if img.shape[1] % 5 != 0: |
| raise its.error.Error('Invalid raw-10 buffer width') |
| w = img.shape[1]*4/5 |
| h = img.shape[0] |
| # Cut out the 4x8b MSBs and shift to bits [9:2] in 16b words. |
| msbs = numpy.delete(img, numpy.s_[4::5], 1) |
| msbs = msbs.astype(numpy.uint16) |
| msbs = numpy.left_shift(msbs, 2) |
| msbs = msbs.reshape(h,w) |
| # Cut out the 4x2b LSBs and put each in bits [1:0] of their own 8b words. |
| lsbs = img[::, 4::5].reshape(h,w/4) |
| lsbs = numpy.right_shift( |
| numpy.packbits(numpy.unpackbits(lsbs).reshape(h,w/4,4,2),3), 6) |
| # Pair the LSB bits group to 0th pixel instead of 3rd pixel |
| lsbs = lsbs.reshape(h,w/4,4)[:,:,::-1] |
| lsbs = lsbs.reshape(h,w) |
| # Fuse the MSBs and LSBs back together |
| img16 = numpy.bitwise_or(msbs, lsbs).reshape(h,w) |
| return img16 |
| |
| |
| def unpack_raw12_capture(cap, props): |
| """Unpack a raw-12 capture to a raw-16 capture. |
| |
| Args: |
| cap: A raw-12 capture object. |
| props: Camera properties object. |
| |
| Returns: |
| New capture object with raw-16 data. |
| """ |
| # Data is packed as 4x10b pixels in 5 bytes, with the first 4 bytes holding |
| # the MSBs of the pixels, and the 5th byte holding 4x2b LSBs. |
| w,h = cap["width"], cap["height"] |
| if w % 2 != 0: |
| raise its.error.Error('Invalid raw-12 buffer width') |
| cap = copy.deepcopy(cap) |
| cap["data"] = unpack_raw12_image(cap["data"].reshape(h,w*3/2)) |
| cap["format"] = "raw" |
| return cap |
| |
| |
| def unpack_raw12_image(img): |
| """Unpack a raw-12 image to a raw-16 image. |
| |
| Output image will have the 12 LSBs filled in each 16b word, and the 4 MSBs |
| will be set to zero. |
| |
| Args: |
| img: A raw-12 image, as a uint8 numpy array. |
| |
| Returns: |
| Image as a uint16 numpy array, with all row padding stripped. |
| """ |
| if img.shape[1] % 3 != 0: |
| raise its.error.Error('Invalid raw-12 buffer width') |
| w = img.shape[1]*2/3 |
| h = img.shape[0] |
| # Cut out the 2x8b MSBs and shift to bits [11:4] in 16b words. |
| msbs = numpy.delete(img, numpy.s_[2::3], 1) |
| msbs = msbs.astype(numpy.uint16) |
| msbs = numpy.left_shift(msbs, 4) |
| msbs = msbs.reshape(h,w) |
| # Cut out the 2x4b LSBs and put each in bits [3:0] of their own 8b words. |
| lsbs = img[::, 2::3].reshape(h,w/2) |
| lsbs = numpy.right_shift( |
| numpy.packbits(numpy.unpackbits(lsbs).reshape(h,w/2,2,4),3), 4) |
| # Pair the LSB bits group to pixel 0 instead of pixel 1 |
| lsbs = lsbs.reshape(h,w/2,2)[:,:,::-1] |
| lsbs = lsbs.reshape(h,w) |
| # Fuse the MSBs and LSBs back together |
| img16 = numpy.bitwise_or(msbs, lsbs).reshape(h,w) |
| return img16 |
| |
| |
| def convert_capture_to_planes(cap, props=None): |
| """Convert a captured image object to separate image planes. |
| |
| Decompose an image into multiple images, corresponding to different planes. |
| |
| For YUV420 captures ("yuv"): |
| Returns Y,U,V planes, where the Y plane is full-res and the U,V planes |
| are each 1/2 x 1/2 of the full res. |
| |
| For Bayer captures ("raw", "raw10", "raw12", or "rawStats"): |
| Returns planes in the order R,Gr,Gb,B, regardless of the Bayer pattern |
| layout. For full-res raw images ("raw", "raw10", "raw12"), each plane |
| is 1/2 x 1/2 of the full res. For "rawStats" images, the mean image |
| is returned. |
| |
| For JPEG captures ("jpeg"): |
| Returns R,G,B full-res planes. |
| |
| Args: |
| cap: A capture object as returned by its.device.do_capture. |
| props: (Optional) camera properties object (of static values); |
| required for processing raw images. |
| |
| Returns: |
| A tuple of float numpy arrays (one per plane), consisting of pixel |
| values in the range [0.0, 1.0]. |
| """ |
| w = cap["width"] |
| h = cap["height"] |
| if cap["format"] == "raw10": |
| assert(props is not None) |
| cap = unpack_raw10_capture(cap, props) |
| if cap["format"] == "raw12": |
| assert(props is not None) |
| cap = unpack_raw12_capture(cap, props) |
| if cap["format"] == "yuv": |
| y = cap["data"][0:w*h] |
| u = cap["data"][w*h:w*h*5/4] |
| v = cap["data"][w*h*5/4:w*h*6/4] |
| return ((y.astype(numpy.float32) / 255.0).reshape(h, w, 1), |
| (u.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1), |
| (v.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1)) |
| elif cap["format"] == "jpeg": |
| rgb = decompress_jpeg_to_rgb_image(cap["data"]).reshape(w*h*3) |
| return (rgb[::3].reshape(h,w,1), |
| rgb[1::3].reshape(h,w,1), |
| rgb[2::3].reshape(h,w,1)) |
| elif cap["format"] == "raw": |
| assert(props is not None) |
| white_level = float(props['android.sensor.info.whiteLevel']) |
| img = numpy.ndarray(shape=(h*w,), dtype='<u2', |
| buffer=cap["data"][0:w*h*2]) |
| img = img.astype(numpy.float32).reshape(h,w) / white_level |
| # Crop the raw image to the active array region. |
| if props.has_key("android.sensor.info.preCorrectionActiveArraySize") \ |
| and props["android.sensor.info.preCorrectionActiveArraySize"] is not None \ |
| and props.has_key("android.sensor.info.pixelArraySize") \ |
| and props["android.sensor.info.pixelArraySize"] is not None: |
| # Note that the Rect class is defined such that the left,top values |
| # are "inside" while the right,bottom values are "outside"; that is, |
| # it's inclusive of the top,left sides only. So, the width is |
| # computed as right-left, rather than right-left+1, etc. |
| wfull = props["android.sensor.info.pixelArraySize"]["width"] |
| hfull = props["android.sensor.info.pixelArraySize"]["height"] |
| xcrop = props["android.sensor.info.preCorrectionActiveArraySize"]["left"] |
| ycrop = props["android.sensor.info.preCorrectionActiveArraySize"]["top"] |
| wcrop = props["android.sensor.info.preCorrectionActiveArraySize"]["right"]-xcrop |
| hcrop = props["android.sensor.info.preCorrectionActiveArraySize"]["bottom"]-ycrop |
| assert(wfull >= wcrop >= 0) |
| assert(hfull >= hcrop >= 0) |
| assert(wfull - wcrop >= xcrop >= 0) |
| assert(hfull - hcrop >= ycrop >= 0) |
| if w == wfull and h == hfull: |
| # Crop needed; extract the center region. |
| img = img[ycrop:ycrop+hcrop,xcrop:xcrop+wcrop] |
| w = wcrop |
| h = hcrop |
| elif w == wcrop and h == hcrop: |
| # No crop needed; image is already cropped to the active array. |
| None |
| else: |
| raise its.error.Error('Invalid image size metadata') |
| # Separate the image planes. |
| imgs = [img[::2].reshape(w*h/2)[::2].reshape(h/2,w/2,1), |
| img[::2].reshape(w*h/2)[1::2].reshape(h/2,w/2,1), |
| img[1::2].reshape(w*h/2)[::2].reshape(h/2,w/2,1), |
| img[1::2].reshape(w*h/2)[1::2].reshape(h/2,w/2,1)] |
| idxs = get_canonical_cfa_order(props) |
| return [imgs[i] for i in idxs] |
| elif cap["format"] == "rawStats": |
| assert(props is not None) |
| white_level = float(props['android.sensor.info.whiteLevel']) |
| mean_image, var_image = its.image.unpack_rawstats_capture(cap) |
| idxs = get_canonical_cfa_order(props) |
| return [mean_image[:,:,i] / white_level for i in idxs] |
| else: |
| raise its.error.Error('Invalid format %s' % (cap["format"])) |
| |
| |
| def get_canonical_cfa_order(props): |
| """Returns a mapping from the Bayer 2x2 top-left grid in the CFA to |
| the standard order R,Gr,Gb,B. |
| |
| Args: |
| props: Camera properties object. |
| |
| Returns: |
| List of 4 integers, corresponding to the positions in the 2x2 top- |
| left Bayer grid of R,Gr,Gb,B, where the 2x2 grid is labeled as |
| 0,1,2,3 in row major order. |
| """ |
| # Note that raw streams aren't croppable, so the cropRegion doesn't need |
| # to be considered when determining the top-left pixel color. |
| cfa_pat = props['android.sensor.info.colorFilterArrangement'] |
| if cfa_pat == 0: |
| # RGGB |
| return [0,1,2,3] |
| elif cfa_pat == 1: |
| # GRBG |
| return [1,0,3,2] |
| elif cfa_pat == 2: |
| # GBRG |
| return [2,3,0,1] |
| elif cfa_pat == 3: |
| # BGGR |
| return [3,2,1,0] |
| else: |
| raise its.error.Error("Not supported") |
| |
| |
| def get_gains_in_canonical_order(props, gains): |
| """Reorders the gains tuple to the canonical R,Gr,Gb,B order. |
| |
| Args: |
| props: Camera properties object. |
| gains: List of 4 values, in R,G_even,G_odd,B order. |
| |
| Returns: |
| List of gains values, in R,Gr,Gb,B order. |
| """ |
| cfa_pat = props['android.sensor.info.colorFilterArrangement'] |
| if cfa_pat in [0,1]: |
| # RGGB or GRBG, so G_even is Gr |
| return gains |
| elif cfa_pat in [2,3]: |
| # GBRG or BGGR, so G_even is Gb |
| return [gains[0], gains[2], gains[1], gains[3]] |
| else: |
| raise its.error.Error("Not supported") |
| |
| |
| def convert_raw_to_rgb_image(r_plane, gr_plane, gb_plane, b_plane, |
| props, cap_res): |
| """Convert a Bayer raw-16 image to an RGB image. |
| |
| Includes some extremely rudimentary demosaicking and color processing |
| operations; the output of this function shouldn't be used for any image |
| quality analysis. |
| |
| Args: |
| r_plane,gr_plane,gb_plane,b_plane: Numpy arrays for each color plane |
| in the Bayer image, with pixels in the [0.0, 1.0] range. |
| props: Camera properties object. |
| cap_res: Capture result (metadata) object. |
| |
| Returns: |
| RGB float-3 image array, with pixel values in [0.0, 1.0] |
| """ |
| # Values required for the RAW to RGB conversion. |
| assert(props is not None) |
| white_level = float(props['android.sensor.info.whiteLevel']) |
| black_levels = props['android.sensor.blackLevelPattern'] |
| gains = cap_res['android.colorCorrection.gains'] |
| ccm = cap_res['android.colorCorrection.transform'] |
| |
| # Reorder black levels and gains to R,Gr,Gb,B, to match the order |
| # of the planes. |
| black_levels = [get_black_level(i,props,cap_res) for i in range(4)] |
| gains = get_gains_in_canonical_order(props, gains) |
| |
| # Convert CCM from rational to float, as numpy arrays. |
| ccm = numpy.array(its.objects.rational_to_float(ccm)).reshape(3,3) |
| |
| # Need to scale the image back to the full [0,1] range after subtracting |
| # the black level from each pixel. |
| scale = white_level / (white_level - max(black_levels)) |
| |
| # Three-channel black levels, normalized to [0,1] by white_level. |
| black_levels = numpy.array([b/white_level for b in [ |
| black_levels[i] for i in [0,1,3]]]) |
| |
| # Three-channel gains. |
| gains = numpy.array([gains[i] for i in [0,1,3]]) |
| |
| h,w = r_plane.shape[:2] |
| img = numpy.dstack([r_plane,(gr_plane+gb_plane)/2.0,b_plane]) |
| img = (((img.reshape(h,w,3) - black_levels) * scale) * gains).clip(0.0,1.0) |
| img = numpy.dot(img.reshape(w*h,3), ccm.T).reshape(h,w,3).clip(0.0,1.0) |
| return img |
| |
| |
| def get_black_level(chan, props, cap_res=None): |
| """Return the black level to use for a given capture. |
| |
| Uses a dynamic value from the capture result if available, else falls back |
| to the static global value in the camera characteristics. |
| |
| Args: |
| chan: The channel index, in canonical order (R, Gr, Gb, B). |
| props: The camera properties object. |
| cap_res: A capture result object. |
| |
| Returns: |
| The black level value for the specified channel. |
| """ |
| if (cap_res is not None and cap_res.has_key('android.sensor.dynamicBlackLevel') and |
| cap_res['android.sensor.dynamicBlackLevel'] is not None): |
| black_levels = cap_res['android.sensor.dynamicBlackLevel'] |
| else: |
| black_levels = props['android.sensor.blackLevelPattern'] |
| idxs = its.image.get_canonical_cfa_order(props) |
| ordered_black_levels = [black_levels[i] for i in idxs] |
| return ordered_black_levels[chan] |
| |
| |
| def convert_yuv420_planar_to_rgb_image(y_plane, u_plane, v_plane, |
| w, h, |
| ccm_yuv_to_rgb=DEFAULT_YUV_TO_RGB_CCM, |
| yuv_off=DEFAULT_YUV_OFFSETS): |
| """Convert a YUV420 8-bit planar image to an RGB image. |
| |
| Args: |
| y_plane: The packed 8-bit Y plane. |
| u_plane: The packed 8-bit U plane. |
| v_plane: The packed 8-bit V plane. |
| w: The width of the image. |
| h: The height of the image. |
| ccm_yuv_to_rgb: (Optional) the 3x3 CCM to convert from YUV to RGB. |
| yuv_off: (Optional) offsets to subtract from each of Y,U,V values. |
| |
| Returns: |
| RGB float-3 image array, with pixel values in [0.0, 1.0]. |
| """ |
| y = numpy.subtract(y_plane, yuv_off[0]) |
| u = numpy.subtract(u_plane, yuv_off[1]).view(numpy.int8) |
| v = numpy.subtract(v_plane, yuv_off[2]).view(numpy.int8) |
| u = u.reshape(h/2, w/2).repeat(2, axis=1).repeat(2, axis=0) |
| v = v.reshape(h/2, w/2).repeat(2, axis=1).repeat(2, axis=0) |
| yuv = numpy.dstack([y, u.reshape(w*h), v.reshape(w*h)]) |
| flt = numpy.empty([h, w, 3], dtype=numpy.float32) |
| flt.reshape(w*h*3)[:] = yuv.reshape(h*w*3)[:] |
| flt = numpy.dot(flt.reshape(w*h,3), ccm_yuv_to_rgb.T).clip(0, 255) |
| rgb = numpy.empty([h, w, 3], dtype=numpy.uint8) |
| rgb.reshape(w*h*3)[:] = flt.reshape(w*h*3)[:] |
| return rgb.astype(numpy.float32) / 255.0 |
| |
| def convert_y8_to_rgb_image(y_plane, w, h): |
| """Convert a Y 8-bit image to an RGB image. |
| |
| Args: |
| y_plane: The packed 8-bit Y plane. |
| w: The width of the image. |
| h: The height of the image. |
| |
| Returns: |
| RGB float-3 image array, with pixel values in [0.0, 1.0]. |
| """ |
| y3 = numpy.dstack([y_plane, y_plane, y_plane]) |
| rgb = numpy.empty([h, w, 3], dtype=numpy.uint8) |
| rgb.reshape(w*h*3)[:] = y3.reshape(w*h*3)[:] |
| return rgb.astype(numpy.float32) / 255.0 |
| |
| def load_rgb_image(fname): |
| """Load a standard image file (JPG, PNG, etc.). |
| |
| Args: |
| fname: The path of the file to load. |
| |
| Returns: |
| RGB float-3 image array, with pixel values in [0.0, 1.0]. |
| """ |
| img = Image.open(fname) |
| w = img.size[0] |
| h = img.size[1] |
| a = numpy.array(img) |
| if len(a.shape) == 3 and a.shape[2] == 3: |
| # RGB |
| return a.reshape(h,w,3) / 255.0 |
| elif len(a.shape) == 2 or len(a.shape) == 3 and a.shape[2] == 1: |
| # Greyscale; convert to RGB |
| return a.reshape(h*w).repeat(3).reshape(h,w,3) / 255.0 |
| else: |
| raise its.error.Error('Unsupported image type') |
| |
| |
| def load_yuv420_to_rgb_image(yuv_fname, |
| w, h, |
| layout="planar", |
| ccm_yuv_to_rgb=DEFAULT_YUV_TO_RGB_CCM, |
| yuv_off=DEFAULT_YUV_OFFSETS): |
| """Load a YUV420 image file, and return as an RGB image. |
| |
| Supported layouts include "planar" and "nv21". The "yuv" formatted captures |
| returned from the device via do_capture are in the "planar" layout; other |
| layouts may only be needed for loading files from other sources. |
| |
| Args: |
| yuv_fname: The path of the YUV420 file. |
| w: The width of the image. |
| h: The height of the image. |
| layout: (Optional) the layout of the YUV data (as a string). |
| ccm_yuv_to_rgb: (Optional) the 3x3 CCM to convert from YUV to RGB. |
| yuv_off: (Optional) offsets to subtract from each of Y,U,V values. |
| |
| Returns: |
| RGB float-3 image array, with pixel values in [0.0, 1.0]. |
| """ |
| with open(yuv_fname, "rb") as f: |
| if layout == "planar": |
| # Plane of Y, plane of V, plane of U. |
| y = numpy.fromfile(f, numpy.uint8, w*h, "") |
| v = numpy.fromfile(f, numpy.uint8, w*h/4, "") |
| u = numpy.fromfile(f, numpy.uint8, w*h/4, "") |
| elif layout == "nv21": |
| # Plane of Y, plane of interleaved VUVUVU... |
| y = numpy.fromfile(f, numpy.uint8, w*h, "") |
| vu = numpy.fromfile(f, numpy.uint8, w*h/2, "") |
| v = vu[0::2] |
| u = vu[1::2] |
| else: |
| raise its.error.Error('Unsupported image layout') |
| return convert_yuv420_planar_to_rgb_image( |
| y,u,v,w,h,ccm_yuv_to_rgb,yuv_off) |
| |
| |
| def load_yuv420_planar_to_yuv_planes(yuv_fname, w, h): |
| """Load a YUV420 planar image file, and return Y, U, and V plane images. |
| |
| Args: |
| yuv_fname: The path of the YUV420 file. |
| w: The width of the image. |
| h: The height of the image. |
| |
| Returns: |
| Separate Y, U, and V images as float-1 Numpy arrays, pixels in [0,1]. |
| Note that pixel (0,0,0) is not black, since U,V pixels are centered at |
| 0.5, and also that the Y and U,V plane images returned are different |
| sizes (due to chroma subsampling in the YUV420 format). |
| """ |
| with open(yuv_fname, "rb") as f: |
| y = numpy.fromfile(f, numpy.uint8, w*h, "") |
| v = numpy.fromfile(f, numpy.uint8, w*h/4, "") |
| u = numpy.fromfile(f, numpy.uint8, w*h/4, "") |
| return ((y.astype(numpy.float32) / 255.0).reshape(h, w, 1), |
| (u.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1), |
| (v.astype(numpy.float32) / 255.0).reshape(h/2, w/2, 1)) |
| |
| |
| def decompress_jpeg_to_rgb_image(jpeg_buffer): |
| """Decompress a JPEG-compressed image, returning as an RGB image. |
| |
| Args: |
| jpeg_buffer: The JPEG stream. |
| |
| Returns: |
| A numpy array for the RGB image, with pixels in [0,1]. |
| """ |
| img = Image.open(cStringIO.StringIO(jpeg_buffer)) |
| w = img.size[0] |
| h = img.size[1] |
| return numpy.array(img).reshape(h,w,3) / 255.0 |
| |
| |
| def apply_lut_to_image(img, lut): |
| """Applies a LUT to every pixel in a float image array. |
| |
| Internally converts to a 16b integer image, since the LUT can work with up |
| to 16b->16b mappings (i.e. values in the range [0,65535]). The lut can also |
| have fewer than 65536 entries, however it must be sized as a power of 2 |
| (and for smaller luts, the scale must match the bitdepth). |
| |
| For a 16b lut of 65536 entries, the operation performed is: |
| |
| lut[r * 65535] / 65535 -> r' |
| lut[g * 65535] / 65535 -> g' |
| lut[b * 65535] / 65535 -> b' |
| |
| For a 10b lut of 1024 entries, the operation becomes: |
| |
| lut[r * 1023] / 1023 -> r' |
| lut[g * 1023] / 1023 -> g' |
| lut[b * 1023] / 1023 -> b' |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| lut: Numpy table encoding a LUT, mapping 16b integer values. |
| |
| Returns: |
| Float image array after applying LUT to each pixel. |
| """ |
| n = len(lut) |
| if n <= 0 or n > MAX_LUT_SIZE or (n & (n - 1)) != 0: |
| raise its.error.Error('Invalid arg LUT size: %d' % (n)) |
| m = float(n-1) |
| return (lut[(img * m).astype(numpy.uint16)] / m).astype(numpy.float32) |
| |
| |
| def apply_matrix_to_image(img, mat): |
| """Multiplies a 3x3 matrix with each float-3 image pixel. |
| |
| Each pixel is considered a column vector, and is left-multiplied by |
| the given matrix: |
| |
| [ ] r r' |
| [ mat ] * g -> g' |
| [ ] b b' |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| mat: Numpy 3x3 matrix. |
| |
| Returns: |
| The numpy float-3 image array resulting from the matrix mult. |
| """ |
| h = img.shape[0] |
| w = img.shape[1] |
| img2 = numpy.empty([h, w, 3], dtype=numpy.float32) |
| img2.reshape(w*h*3)[:] = (numpy.dot(img.reshape(h*w, 3), mat.T) |
| ).reshape(w*h*3)[:] |
| return img2 |
| |
| |
| def get_image_patch(img, xnorm, ynorm, wnorm, hnorm): |
| """Get a patch (tile) of an image. |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| xnorm,ynorm,wnorm,hnorm: Normalized (in [0,1]) coords for the tile. |
| |
| Returns: |
| Float image array of the patch. |
| """ |
| hfull = img.shape[0] |
| wfull = img.shape[1] |
| xtile = int(math.ceil(xnorm * wfull)) |
| ytile = int(math.ceil(ynorm * hfull)) |
| wtile = int(math.floor(wnorm * wfull)) |
| htile = int(math.floor(hnorm * hfull)) |
| if len(img.shape)==2: |
| return img[ytile:ytile+htile,xtile:xtile+wtile].copy() |
| else: |
| return img[ytile:ytile+htile,xtile:xtile+wtile,:].copy() |
| |
| |
| def compute_image_means(img): |
| """Calculate the mean of each color channel in the image. |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| |
| Returns: |
| A list of mean values, one per color channel in the image. |
| """ |
| means = [] |
| chans = img.shape[2] |
| for i in xrange(chans): |
| means.append(numpy.mean(img[:,:,i], dtype=numpy.float64)) |
| return means |
| |
| |
| def compute_image_variances(img): |
| """Calculate the variance of each color channel in the image. |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| |
| Returns: |
| A list of mean values, one per color channel in the image. |
| """ |
| variances = [] |
| chans = img.shape[2] |
| for i in xrange(chans): |
| variances.append(numpy.var(img[:,:,i], dtype=numpy.float64)) |
| return variances |
| |
| |
| def compute_image_snrs(img): |
| """Calculate the SNR (db) of each color channel in the image. |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| |
| Returns: |
| A list of SNR value, one per color channel in the image. |
| """ |
| means = compute_image_means(img) |
| variances = compute_image_variances(img) |
| std_devs = [math.sqrt(v) for v in variances] |
| snr = [20 * math.log10(m/s) for m,s in zip(means, std_devs)] |
| return snr |
| |
| |
| def compute_image_max_gradients(img): |
| """Calculate the maximum gradient of each color channel in the image. |
| |
| Args: |
| img: Numpy float image array, with pixel values in [0,1]. |
| |
| Returns: |
| A list of gradient max values, one per color channel in the image. |
| """ |
| grads = [] |
| chans = img.shape[2] |
| for i in xrange(chans): |
| grads.append(numpy.amax(numpy.gradient(img[:, :, i]))) |
| return grads |
| |
| |
| def write_image(img, fname, apply_gamma=False): |
| """Save a float-3 numpy array image to a file. |
| |
| Supported formats: PNG, JPEG, and others; see PIL docs for more. |
| |
| Image can be 3-channel, which is interpreted as RGB, or can be 1-channel, |
| which is greyscale. |
| |
| Can optionally specify that the image should be gamma-encoded prior to |
| writing it out; this should be done if the image contains linear pixel |
| values, to make the image look "normal". |
| |
| Args: |
| img: Numpy image array data. |
| fname: Path of file to save to; the extension specifies the format. |
| apply_gamma: (Optional) apply gamma to the image prior to writing it. |
| """ |
| if apply_gamma: |
| img = apply_lut_to_image(img, DEFAULT_GAMMA_LUT) |
| (h, w, chans) = img.shape |
| if chans == 3: |
| Image.fromarray((img * 255.0).astype(numpy.uint8), "RGB").save(fname) |
| elif chans == 1: |
| img3 = (img * 255.0).astype(numpy.uint8).repeat(3).reshape(h,w,3) |
| Image.fromarray(img3, "RGB").save(fname) |
| else: |
| raise its.error.Error('Unsupported image type') |
| |
| |
| def downscale_image(img, f): |
| """Shrink an image by a given integer factor. |
| |
| This function computes output pixel values by averaging over rectangular |
| regions of the input image; it doesn't skip or sample pixels, and all input |
| image pixels are evenly weighted. |
| |
| If the downscaling factor doesn't cleanly divide the width and/or height, |
| then the remaining pixels on the right or bottom edge are discarded prior |
| to the downscaling. |
| |
| Args: |
| img: The input image as an ndarray. |
| f: The downscaling factor, which should be an integer. |
| |
| Returns: |
| The new (downscaled) image, as an ndarray. |
| """ |
| h,w,chans = img.shape |
| f = int(f) |
| assert(f >= 1) |
| h = (h/f)*f |
| w = (w/f)*f |
| img = img[0:h:,0:w:,::] |
| chs = [] |
| for i in xrange(chans): |
| ch = img.reshape(h*w*chans)[i::chans].reshape(h,w) |
| ch = ch.reshape(h,w/f,f).mean(2).reshape(h,w/f) |
| ch = ch.T.reshape(w/f,h/f,f).mean(2).T.reshape(h/f,w/f) |
| chs.append(ch.reshape(h*w/(f*f))) |
| img = numpy.vstack(chs).T.reshape(h/f,w/f,chans) |
| return img |
| |
| |
| def compute_image_sharpness(img): |
| """Calculate the sharpness of input image. |
| |
| Args: |
| img: Numpy float RGB/luma image array, with pixel values in [0,1]. |
| |
| Returns: |
| A sharpness estimation value based on the average of gradient magnitude. |
| Larger value means the image is sharper. |
| """ |
| chans = img.shape[2] |
| assert(chans == 1 or chans == 3) |
| if (chans == 1): |
| luma = img[:, :, 0] |
| elif (chans == 3): |
| luma = 0.299 * img[:,:,0] + 0.587 * img[:,:,1] + 0.114 * img[:,:,2] |
| |
| [gy, gx] = numpy.gradient(luma) |
| return numpy.average(numpy.sqrt(gy*gy + gx*gx)) |
| |
| |
| def normalize_img(img): |
| """Normalize the image values to between 0 and 1. |
| |
| Args: |
| img: 2-D numpy array of image values |
| Returns: |
| Normalized image |
| """ |
| return (img - numpy.amin(img))/(numpy.amax(img) - numpy.amin(img)) |
| |
| |
| def chart_located_per_argv(): |
| """Determine if chart already located outside of test. |
| |
| If chart info provided, return location and size. If not, return None. |
| |
| Args: |
| None |
| Returns: |
| chart_loc: float converted xnorm,ynorm,wnorm,hnorm,scale from argv text. |
| argv is of form 'chart_loc=0.45,0.45,0.1,0.1,1.0' |
| """ |
| for s in sys.argv[1:]: |
| if s[:10] == "chart_loc=" and len(s) > 10: |
| chart_loc = s[10:].split(",") |
| return map(float, chart_loc) |
| return None, None, None, None, None |
| |
| |
| def rotate_img_per_argv(img): |
| """Rotate an image 180 degrees if "rotate" is in argv |
| |
| Args: |
| img: 2-D numpy array of image values |
| Returns: |
| Rotated image |
| """ |
| img_out = img |
| if "rotate180" in sys.argv: |
| img_out = numpy.fliplr(numpy.flipud(img_out)) |
| return img_out |
| |
| |
| def stationary_lens_cap(cam, req, fmt): |
| """Take up to NUM_TRYS caps and save the 1st one with lens stationary. |
| |
| Args: |
| cam: open device session |
| req: capture request |
| fmt: format for capture |
| |
| Returns: |
| capture |
| """ |
| trys = 0 |
| done = False |
| reqs = [req] * NUM_FRAMES |
| while not done: |
| print 'Waiting for lens to move to correct location...' |
| cap = cam.do_capture(reqs, fmt) |
| done = (cap[NUM_FRAMES-1]['metadata']['android.lens.state'] == 0) |
| print ' status: ', done |
| trys += 1 |
| if trys == NUM_TRYS: |
| raise its.error.Error('Cannot settle lens after %d trys!' % trys) |
| return cap[NUM_FRAMES-1] |
| |
| |
| class __UnitTest(unittest.TestCase): |
| """Run a suite of unit tests on this module. |
| """ |
| |
| # TODO: Add more unit tests. |
| |
| def test_apply_matrix_to_image(self): |
| """Unit test for apply_matrix_to_image. |
| |
| Test by using a canned set of values on a 1x1 pixel image. |
| |
| [ 1 2 3 ] [ 0.1 ] [ 1.4 ] |
| [ 4 5 6 ] * [ 0.2 ] = [ 3.2 ] |
| [ 7 8 9 ] [ 0.3 ] [ 5.0 ] |
| mat x y |
| """ |
| mat = numpy.array([[1,2,3], [4,5,6], [7,8,9]]) |
| x = numpy.array([0.1,0.2,0.3]).reshape(1,1,3) |
| y = apply_matrix_to_image(x, mat).reshape(3).tolist() |
| y_ref = [1.4,3.2,5.0] |
| passed = all([math.fabs(y[i] - y_ref[i]) < 0.001 for i in xrange(3)]) |
| self.assertTrue(passed) |
| |
| def test_apply_lut_to_image(self): |
| """Unit test for apply_lut_to_image. |
| |
| Test by using a canned set of values on a 1x1 pixel image. The LUT will |
| simply double the value of the index: |
| |
| lut[x] = 2*x |
| """ |
| lut = numpy.array([2*i for i in xrange(65536)]) |
| x = numpy.array([0.1,0.2,0.3]).reshape(1,1,3) |
| y = apply_lut_to_image(x, lut).reshape(3).tolist() |
| y_ref = [0.2,0.4,0.6] |
| passed = all([math.fabs(y[i] - y_ref[i]) < 0.001 for i in xrange(3)]) |
| self.assertTrue(passed) |
| |
| def test_unpack_raw10_image(self): |
| """Unit test for unpack_raw10_image. |
| |
| RAW10 bit packing format |
| bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0 |
| Byte 0: P0[9] P0[8] P0[7] P0[6] P0[5] P0[4] P0[3] P0[2] |
| Byte 1: P1[9] P1[8] P1[7] P1[6] P1[5] P1[4] P1[3] P1[2] |
| Byte 2: P2[9] P2[8] P2[7] P2[6] P2[5] P2[4] P2[3] P2[2] |
| Byte 3: P3[9] P3[8] P3[7] P3[6] P3[5] P3[4] P3[3] P3[2] |
| Byte 4: P3[1] P3[0] P2[1] P2[0] P1[1] P1[0] P0[1] P0[0] |
| """ |
| # test by using a random 4x4 10-bit image |
| H = 4 |
| W = 4 |
| check_list = random.sample(range(0, 1024), H*W) |
| img_check = numpy.array(check_list).reshape(H, W) |
| # pack bits |
| for row_start in range(0, len(check_list), W): |
| msbs = [] |
| lsbs = "" |
| for pixel in range(W): |
| val = numpy.binary_repr(check_list[row_start+pixel], 10) |
| msbs.append(int(val[:8], base=2)) |
| lsbs = val[8:] + lsbs |
| packed = msbs |
| packed.append(int(lsbs, base=2)) |
| chunk_raw10 = numpy.array(packed, dtype="uint8").reshape(1, 5) |
| if row_start == 0: |
| img_raw10 = chunk_raw10 |
| else: |
| img_raw10 = numpy.vstack((img_raw10, chunk_raw10)) |
| # unpack and check against original |
| self.assertTrue(numpy.array_equal(unpack_raw10_image(img_raw10), |
| img_check)) |
| |
| if __name__ == "__main__": |
| unittest.main() |
