# Copyright 2015 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 os.path import its.caps import its.device import its.image import its.objects import its.target import matplotlib from matplotlib import pylab import numpy NAME = os.path.basename(__file__).split(".")[0] NR_MODES = [0, 1, 2, 3, 4] NUM_FRAMES = 4 SNR_TOLERANCE = 3 # unit in dB def main(): """Test android.noiseReduction.mode is applied for reprocessing requests. Capture reprocessed images with the camera dimly lit. Uses a high analog gain to ensure the captured image is noisy. Captures three reprocessed images, for NR off, "fast", and "high quality". Also captures a reprocessed image with low gain and NR off, and uses the variance of this as the baseline. """ with its.device.ItsSession() as cam: props = cam.get_camera_properties() its.caps.skip_unless(its.caps.compute_target_exposure(props) and its.caps.per_frame_control(props) and its.caps.noise_reduction_mode(props, 0) and (its.caps.yuv_reprocess(props) or its.caps.private_reprocess(props))) # If reprocessing is supported, ZSL NR mode must be avaiable. assert its.caps.noise_reduction_mode(props, 4) reprocess_formats = [] if its.caps.yuv_reprocess(props): reprocess_formats.append("yuv") if its.caps.private_reprocess(props): reprocess_formats.append("private") for reprocess_format in reprocess_formats: print "\nreprocess format:", reprocess_format # List of variances for R, G, B. snrs = [[], [], []] nr_modes_reported = [] # NR mode 0 with low gain e, s = its.target.get_target_exposure_combos(cam)["minSensitivity"] req = its.objects.manual_capture_request(s, e) req["android.noiseReduction.mode"] = 0 # Test reprocess_format->JPEG reprocessing # TODO: Switch to reprocess_format->YUV when YUV reprocessing is # supported. size = its.objects.get_available_output_sizes("jpg", props)[0] out_surface = {"width": size[0], "height": size[1], "format": "jpg"} cap = cam.do_capture(req, out_surface, reprocess_format) img = its.image.decompress_jpeg_to_rgb_image(cap["data"]) its.image.write_image(img, "%s_low_gain_fmt=jpg.jpg" % NAME) tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1) ref_snr = its.image.compute_image_snrs(tile) print "Ref SNRs:", ref_snr e, s = its.target.get_target_exposure_combos(cam)["maxSensitivity"] for nr_mode in NR_MODES: # Skip unavailable modes if not its.caps.noise_reduction_mode(props, nr_mode): nr_modes_reported.append(nr_mode) for channel in range(3): snrs[channel].append(0) continue rgb_snr_list = [] # Capture several images to account for per frame noise # variations req = its.objects.manual_capture_request(s, e) req["android.noiseReduction.mode"] = nr_mode caps = cam.do_capture( [req]*NUM_FRAMES, out_surface, reprocess_format) for n in range(NUM_FRAMES): img = its.image.decompress_jpeg_to_rgb_image( caps[n]["data"]) if n == 0: its.image.write_image( img, "%s_high_gain_nr=%d_fmt=jpg.jpg" % ( NAME, nr_mode)) nr_modes_reported.append( caps[n]["metadata"]["android.noiseReduction.mode"]) tile = its.image.get_image_patch(img, 0.45, 0.45, 0.1, 0.1) # Get the variances for R, G, and B channels rgb_snrs = its.image.compute_image_snrs(tile) rgb_snr_list.append(rgb_snrs) r_snrs = [rgb[0] for rgb in rgb_snr_list] g_snrs = [rgb[1] for rgb in rgb_snr_list] b_snrs = [rgb[2] for rgb in rgb_snr_list] rgb_snrs = [numpy.mean(r_snrs), numpy.mean(g_snrs), numpy.mean(b_snrs)] print "NR mode", nr_mode, "SNRs:" print " R SNR:", rgb_snrs[0], print "Min:", min(r_snrs), "Max:", max(r_snrs) print " G SNR:", rgb_snrs[1], print "Min:", min(g_snrs), "Max:", max(g_snrs) print " B SNR:", rgb_snrs[2], print "Min:", min(b_snrs), "Max:", max(b_snrs) for chan in range(3): snrs[chan].append(rgb_snrs[chan]) # Draw a plot. pylab.figure(reprocess_format) for channel in range(3): pylab.plot(NR_MODES, snrs[channel], "-"+"rgb"[channel]+"o") pylab.title(NAME + ", reprocess_fmt=" + reprocess_format) pylab.xlabel("Noise Reduction Mode") pylab.ylabel("SNR (dB)") pylab.xticks(NR_MODES) matplotlib.pyplot.savefig("%s_plot_%s_SNRs.png" % (NAME, reprocess_format)) assert nr_modes_reported == NR_MODES for j in range(3): # Verify OFF(0) is not better than FAST(1) msg = "FAST(1): %.2f, OFF(0): %.2f, TOL: %f" % ( snrs[j][1], snrs[j][0], SNR_TOLERANCE) assert snrs[j][0] < snrs[j][1] + SNR_TOLERANCE, msg # Verify FAST(1) is not better than HQ(2) msg = "HQ(2): %.2f, FAST(1): %.2f, TOL: %f" % ( snrs[j][2], snrs[j][1], SNR_TOLERANCE) assert snrs[j][1] < snrs[j][2] + SNR_TOLERANCE, msg # Verify HQ(2) is better than OFF(0) msg = "HQ(2): %.2f, OFF(0): %.2f" % (snrs[j][2], snrs[j][0]) assert snrs[j][0] < snrs[j][2], msg if its.caps.noise_reduction_mode(props, 3): # Verify OFF(0) is not better than MINIMAL(3) msg = "MINIMAL(3): %.2f, OFF(0): %.2f, TOL: %f" % ( snrs[j][3], snrs[j][0], SNR_TOLERANCE) assert snrs[j][0] < snrs[j][3] + SNR_TOLERANCE, msg # Verify MINIMAL(3) is not better than HQ(2) msg = "MINIMAL(3): %.2f, HQ(2): %.2f, TOL: %f" % ( snrs[j][3], snrs[j][2], SNR_TOLERANCE) assert snrs[j][3] < snrs[j][2] + SNR_TOLERANCE, msg # Verify ZSL(4) is close to MINIMAL(3) msg = "ZSL(4): %.2f, MINIMAL(3): %.2f, TOL: %f" % ( snrs[j][4], snrs[j][3], SNR_TOLERANCE) assert numpy.isclose(snrs[j][4], snrs[j][3], atol=SNR_TOLERANCE), msg else: # Verify ZSL(4) is close to OFF(0) msg = "ZSL(4): %.2f, OFF(0): %.2f, TOL: %f" % ( snrs[j][4], snrs[j][0], SNR_TOLERANCE) assert numpy.isclose(snrs[j][4], snrs[j][0], atol=SNR_TOLERANCE), msg if __name__ == "__main__": main()