| # Copyright 2015 The Android Open Source Project (lint as: python2) |
| # |
| # 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 math |
| import os.path |
| import cv2 |
| import its.caps |
| import its.cv2image |
| import its.device |
| import its.image |
| import its.objects |
| import numpy as np |
| |
| FOV_PERCENT_RTOL = 0.15 # Relative tolerance on circle FoV % to expected |
| LARGE_SIZE = 2000 # Define the size of a large image (compare against max(w,h)) |
| NAME = os.path.basename(__file__).split(".")[0] |
| NUM_DISTORT_PARAMS = 5 |
| THRESH_L_AR = 0.02 # aspect ratio test threshold of large images |
| THRESH_XS_AR = 0.075 # aspect ratio test threshold of mini images |
| THRESH_L_CP = 0.02 # Crop test threshold of large images |
| THRESH_XS_CP = 0.075 # Crop test threshold of mini images |
| THRESH_MIN_PIXEL = 4 # Crop test allowed offset |
| PREVIEW_SIZE = (1920, 1080) # preview size |
| |
| # Before API level 30, only resolutions with the following listed aspect ratio |
| # are checked. Device launched after API level 30 will need to pass the test |
| # for all advertised resolutions. Device launched before API level 30 just |
| # needs to pass the test for all resolutions within these aspect ratios. |
| AR_CHECKED_PRE_API_30 = ["4:3", "16:9", "18:9"] |
| AR_DIFF_ATOL = 0.01 |
| |
| |
| def print_failed_test_results(failed_ar, failed_fov, failed_crop): |
| """Print failed test results.""" |
| if failed_ar: |
| print "\nAspect ratio test summary" |
| print "Images failed in the aspect ratio test:" |
| print "Aspect ratio value: width / height" |
| for fa in failed_ar: |
| print "%s with %s %dx%d: %.3f;" % ( |
| fa["fmt_iter"], fa["fmt_cmpr"], |
| fa["w"], fa["h"], fa["ar"]), |
| print "valid range: %.3f ~ %.3f" % ( |
| fa["valid_range"][0], fa["valid_range"][1]) |
| |
| if failed_fov: |
| print "\nFoV test summary" |
| print "Images failed in the FoV test:" |
| for fov in failed_fov: |
| print fov |
| |
| if failed_crop: |
| print "\nCrop test summary" |
| print "Images failed in the crop test:" |
| print "Circle center position, (horizontal x vertical), listed", |
| print "below is relative to the image center." |
| for fc in failed_crop: |
| print "%s with %s %dx%d: %.3f x %.3f;" % ( |
| fc["fmt_iter"], fc["fmt_cmpr"], fc["w"], fc["h"], |
| fc["ct_hori"], fc["ct_vert"]), |
| print "valid horizontal range: %.3f ~ %.3f;" % ( |
| fc["valid_range_h"][0], fc["valid_range_h"][1]), |
| print "valid vertical range: %.3f ~ %.3f" % ( |
| fc["valid_range_v"][0], fc["valid_range_v"][1]) |
| |
| |
| def is_checked_aspect_ratio(first_api_level, w, h): |
| if first_api_level >= 30: |
| return True |
| |
| for ar_check in AR_CHECKED_PRE_API_30: |
| match_ar_list = [float(x) for x in ar_check.split(":")] |
| match_ar = match_ar_list[0] / match_ar_list[1] |
| if np.isclose(float(w)/h, match_ar, atol=AR_DIFF_ATOL): |
| return True |
| |
| return False |
| |
| def calc_expected_circle_image_ratio(ref_fov, img_w, img_h): |
| """Determine the circle image area ratio in percentage for a given image size. |
| |
| Args: |
| ref_fov: dict with [fmt, % coverage, w, h, circle_w, circle_h] |
| img_w: the image width |
| img_h: the image height |
| |
| Returns: |
| chk_percent: the expected circle image area ratio in percentage |
| """ |
| |
| ar_ref = float(ref_fov["w"]) / ref_fov["h"] |
| ar_target = float(img_w) / img_h |
| # The cropping will happen either horizontally or vertically. |
| # In both case a crop results in the visble area reduce by a ratio r (r < 1.0) |
| # and the circle will in turn occupy ref_pct / r (percent) on the target |
| # image size. |
| r = ar_ref / ar_target |
| if r < 1.0: |
| r = 1.0 / r |
| return ref_fov["percent"] * r |
| |
| |
| def find_raw_fov_reference(cam, req, props, debug): |
| """Determine the circle coverage of the image in RAW reference image. |
| |
| Args: |
| cam: camera object |
| req: camera request |
| props: camera properties |
| debug: perform debug dump or not |
| |
| Returns: |
| ref_fov: dict with [fmt, % coverage, w, h, circle_w, circle_h] |
| cc_ct_gt: circle center position relative to the center of image. |
| aspect_ratio_gt: aspect ratio of the detected circle in float. |
| """ |
| |
| # Capture full-frame raw. Use its aspect ratio and circle center |
| # location as ground truth for the other jpeg or yuv images. |
| print "Creating references for fov_coverage from RAW" |
| out_surface = {"format": "raw"} |
| cap_raw = cam.do_capture(req, out_surface) |
| print "Captured %s %dx%d" % ("raw", cap_raw["width"], |
| cap_raw["height"]) |
| img_raw = its.image.convert_capture_to_rgb_image(cap_raw, |
| props=props) |
| |
| # The intrinsics and distortion coefficients are meant for full |
| # size RAW, but convert_capture_to_rgb_image returns a 2x downsampled |
| # version, so resize back to full size here. |
| img_raw = cv2.resize(img_raw, (0, 0), fx=2.0, fy=2.0) |
| |
| # If the device supports lens distortion correction, apply the |
| # coefficients on the RAW image so it can be compared to YUV/JPEG |
| # outputs which are subject to the same correction via ISP. |
| if its.caps.distortion_correction(props): |
| # Intrinsic cal is of format: [f_x, f_y, c_x, c_y, s] |
| # [f_x, f_y] is the horizontal and vertical focal lengths, |
| # [c_x, c_y] is the position of the optical axis, |
| # and s is skew of sensor plane vs lens plane. |
| print "Applying intrinsic calibration and distortion params" |
| ical = np.array(props["android.lens.intrinsicCalibration"]) |
| msg = "Cannot include lens distortion without intrinsic cal!" |
| assert len(ical) == 5, msg |
| sensor_h = props["android.sensor.info.physicalSize"]["height"] |
| sensor_w = props["android.sensor.info.physicalSize"]["width"] |
| pixel_h = props["android.sensor.info.pixelArraySize"]["height"] |
| pixel_w = props["android.sensor.info.pixelArraySize"]["width"] |
| fd = float(cap_raw["metadata"]["android.lens.focalLength"]) |
| fd_w_pix = pixel_w * fd / sensor_w |
| fd_h_pix = pixel_h * fd / sensor_h |
| # transformation matrix |
| # k = [[f_x, s, c_x], |
| # [0, f_y, c_y], |
| # [0, 0, 1]] |
| k = np.array([[ical[0], ical[4], ical[2]], |
| [0, ical[1], ical[3]], |
| [0, 0, 1]]) |
| print "k:", k |
| e_msg = "fd_w(pixels): %.2f\tcal[0](pixels): %.2f\tTOL=20%%" % ( |
| fd_w_pix, ical[0]) |
| assert np.isclose(fd_w_pix, ical[0], rtol=0.20), e_msg |
| e_msg = "fd_h(pixels): %.2f\tcal[1](pixels): %.2f\tTOL=20%%" % ( |
| fd_h_pix, ical[0]) |
| assert np.isclose(fd_h_pix, ical[1], rtol=0.20), e_msg |
| |
| # distortion |
| rad_dist = props["android.lens.distortion"] |
| print "android.lens.distortion:", rad_dist |
| e_msg = "%s param(s) found. %d expected." % (len(rad_dist), |
| NUM_DISTORT_PARAMS) |
| assert len(rad_dist) == NUM_DISTORT_PARAMS, e_msg |
| opencv_dist = np.array([rad_dist[0], rad_dist[1], |
| rad_dist[3], rad_dist[4], |
| rad_dist[2]]) |
| print "dist:", opencv_dist |
| img_raw = cv2.undistort(img_raw, k, opencv_dist) |
| size_raw = img_raw.shape |
| w_raw = size_raw[1] |
| h_raw = size_raw[0] |
| img_name = "%s_%s_w%d_h%d.png" % (NAME, "raw", w_raw, h_raw) |
| its.image.write_image(img_raw, img_name, True) |
| aspect_ratio_gt, cc_ct_gt, circle_size_raw = measure_aspect_ratio( |
| img_raw, img_name, True, debug) |
| raw_fov_percent = calc_circle_image_ratio( |
| circle_size_raw[0], circle_size_raw[1], w_raw, h_raw) |
| ref_fov = {} |
| ref_fov["fmt"] = "RAW" |
| ref_fov["percent"] = raw_fov_percent |
| ref_fov["w"] = w_raw |
| ref_fov["h"] = h_raw |
| ref_fov["circle_w"] = circle_size_raw[0] |
| ref_fov["circle_h"] = circle_size_raw[1] |
| print "Using RAW reference:", ref_fov |
| return ref_fov, cc_ct_gt, aspect_ratio_gt |
| |
| |
| def find_jpeg_fov_reference(cam, req, props): |
| """Determine the circle coverage of the image in JPEG reference image. |
| |
| Args: |
| cam: camera object |
| req: camera request |
| props: camera properties |
| |
| Returns: |
| ref_fov: dict with [fmt, % coverage, w, h, circle_w, circle_h] |
| cc_ct_gt: circle center position relative to the center of image. |
| """ |
| ref_fov = {} |
| fmt = its.objects.get_largest_jpeg_format(props) |
| # capture and determine circle area in image |
| cap = cam.do_capture(req, fmt) |
| w = cap["width"] |
| h = cap["height"] |
| |
| img = its.image.convert_capture_to_rgb_image(cap, props=props) |
| print "Captured JPEG %dx%d" % (w, h) |
| img_name = "%s_jpeg_w%d_h%d.png" % (NAME, w, h) |
| # Set debug to True to save the reference image |
| _, cc_ct_gt, circle_size = measure_aspect_ratio(img, img_name, False, debug=True) |
| fov_percent = calc_circle_image_ratio(circle_size[0], circle_size[1], w, h) |
| ref_fov["fmt"] = "JPEG" |
| ref_fov["percent"] = fov_percent |
| ref_fov["w"] = w |
| ref_fov["h"] = h |
| ref_fov["circle_w"] = circle_size[0] |
| ref_fov["circle_h"] = circle_size[1] |
| print "Using JPEG reference:", ref_fov |
| return ref_fov, cc_ct_gt |
| |
| |
| def calc_circle_image_ratio(circle_w, circle_h, image_w, image_h): |
| """Calculate the percent of area the input circle covers in input image. |
| |
| Args: |
| circle_w (int): width of circle |
| circle_h (int): height of circle |
| image_w (int): width of image |
| image_h (int): height of image |
| Returns: |
| fov_percent (float): % of image covered by circle |
| """ |
| circle_area = math.pi * math.pow(np.mean([circle_w, circle_h])/2.0, 2) |
| image_area = image_w * image_h |
| fov_percent = 100*circle_area/image_area |
| return fov_percent |
| |
| |
| def measure_aspect_ratio(img, img_name, raw_avlb, debug): |
| """Measure the aspect ratio of the black circle in the test image. |
| |
| Args: |
| img: Numpy float image array in RGB, with pixel values in [0,1]. |
| img_name: string with image info of format and size. |
| raw_avlb: True: raw capture is available; False: raw capture is not |
| available. |
| debug: boolean for whether in debug mode. |
| Returns: |
| aspect_ratio: aspect ratio number in float. |
| cc_ct: circle center position relative to the center of image. |
| (circle_w, circle_h): tuple of the circle size |
| """ |
| size = img.shape |
| img *= 255 |
| # Gray image |
| img_gray = 0.299*img[:, :, 2] + 0.587*img[:, :, 1] + 0.114*img[:, :, 0] |
| |
| # otsu threshold to binarize the image |
| _, img_bw = cv2.threshold(np.uint8(img_gray), 0, 255, |
| cv2.THRESH_BINARY + cv2.THRESH_OTSU) |
| |
| # connected component |
| cv2_version = cv2.__version__ |
| if cv2_version.startswith('3.'): # OpenCV 3.x |
| _, contours, hierarchy = cv2.findContours( |
| 255-img_bw, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) |
| else: # OpenCV 2.x and 4.x |
| contours, hierarchy = cv2.findContours( |
| 255-img_bw, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) |
| |
| # Check each component and find the black circle |
| min_cmpt = size[0] * size[1] * 0.005 |
| max_cmpt = size[0] * size[1] * 0.35 |
| num_circle = 0 |
| aspect_ratio = 0 |
| for ct, hrch in zip(contours, hierarchy[0]): |
| # The radius of the circle is 1/3 of the length of the square, meaning |
| # around 1/3 of the area of the square |
| # Parental component should exist and the area is acceptable. |
| # The coutour of a circle should have at least 5 points |
| child_area = cv2.contourArea(ct) |
| if (hrch[3] == -1 or child_area < min_cmpt or child_area > max_cmpt |
| or len(ct) < 15): |
| continue |
| # Check the shapes of current component and its parent |
| child_shape = its.cv2image.component_shape(ct) |
| parent = hrch[3] |
| prt_shape = its.cv2image.component_shape(contours[parent]) |
| prt_area = cv2.contourArea(contours[parent]) |
| dist_x = abs(child_shape["ctx"]-prt_shape["ctx"]) |
| dist_y = abs(child_shape["cty"]-prt_shape["cty"]) |
| # 1. 0.56*Parent"s width < Child"s width < 0.76*Parent"s width. |
| # 2. 0.56*Parent"s height < Child"s height < 0.76*Parent"s height. |
| # 3. Child"s width > 0.1*Image width |
| # 4. Child"s height > 0.1*Image height |
| # 5. 0.25*Parent"s area < Child"s area < 0.45*Parent"s area |
| # 6. Child == 0, and Parent == 255 |
| # 7. Center of Child and center of parent should overlap |
| if (prt_shape["width"] * 0.56 < child_shape["width"] |
| < prt_shape["width"] * 0.76 |
| and prt_shape["height"] * 0.56 < child_shape["height"] |
| < prt_shape["height"] * 0.76 |
| and child_shape["width"] > 0.1 * size[1] |
| and child_shape["height"] > 0.1 * size[0] |
| and 0.30 * prt_area < child_area < 0.50 * prt_area |
| and img_bw[child_shape["cty"]][child_shape["ctx"]] == 0 |
| and img_bw[child_shape["top"]][child_shape["left"]] == 255 |
| and dist_x < 0.1 * child_shape["width"] |
| and dist_y < 0.1 * child_shape["height"]): |
| # If raw capture is not available, check the camera is placed right |
| # in front of the test page: |
| # 1. Distances between parent and child horizontally on both side,0 |
| # dist_left and dist_right, should be close. |
| # 2. Distances between parent and child vertically on both side, |
| # dist_top and dist_bottom, should be close. |
| if not raw_avlb: |
| dist_left = child_shape["left"] - prt_shape["left"] |
| dist_right = prt_shape["right"] - child_shape["right"] |
| dist_top = child_shape["top"] - prt_shape["top"] |
| dist_bottom = prt_shape["bottom"] - child_shape["bottom"] |
| if (abs(dist_left-dist_right) > 0.05 * child_shape["width"] |
| or abs(dist_top-dist_bottom) > 0.05 * child_shape["height"]): |
| continue |
| # Calculate aspect ratio |
| aspect_ratio = float(child_shape["width"]) / child_shape["height"] |
| circle_ctx = child_shape["ctx"] |
| circle_cty = child_shape["cty"] |
| circle_w = float(child_shape["width"]) |
| circle_h = float(child_shape["height"]) |
| cc_ct = {"hori": float(child_shape["ctx"]-size[1]/2) / circle_w, |
| "vert": float(child_shape["cty"]-size[0]/2) / circle_h} |
| num_circle += 1 |
| # If more than one circle found, break |
| if num_circle == 2: |
| break |
| |
| if num_circle == 0: |
| its.image.write_image(img/255, img_name, True) |
| print "No black circle was detected. Please take pictures according", |
| print "to instruction carefully!\n" |
| assert num_circle == 1 |
| |
| if num_circle > 1: |
| its.image.write_image(img/255, img_name, True) |
| print "More than one black circle was detected. Background of scene", |
| print "may be too complex.\n" |
| assert num_circle == 1 |
| |
| # draw circle center and image center, and save the image |
| line_width = max(1, max(size)/500) |
| move_text_dist = line_width * 3 |
| cv2.line(img, (circle_ctx, circle_cty), (size[1]/2, size[0]/2), |
| (255, 0, 0), line_width) |
| if circle_cty > size[0]/2: |
| move_text_down_circle = 4 |
| move_text_down_image = -1 |
| else: |
| move_text_down_circle = -1 |
| move_text_down_image = 4 |
| if circle_ctx > size[1]/2: |
| move_text_right_circle = 2 |
| move_text_right_image = -1 |
| else: |
| move_text_right_circle = -1 |
| move_text_right_image = 2 |
| # circle center |
| text_circle_x = move_text_dist * move_text_right_circle + circle_ctx |
| text_circle_y = move_text_dist * move_text_down_circle + circle_cty |
| cv2.circle(img, (circle_ctx, circle_cty), line_width*2, (255, 0, 0), -1) |
| cv2.putText(img, "circle center", (text_circle_x, text_circle_y), |
| cv2.FONT_HERSHEY_SIMPLEX, line_width/2.0, (255, 0, 0), |
| line_width) |
| # image center |
| text_imgct_x = move_text_dist * move_text_right_image + size[1]/2 |
| text_imgct_y = move_text_dist * move_text_down_image + size[0]/2 |
| cv2.circle(img, (size[1]/2, size[0]/2), line_width*2, (255, 0, 0), -1) |
| cv2.putText(img, "image center", (text_imgct_x, text_imgct_y), |
| cv2.FONT_HERSHEY_SIMPLEX, line_width/2.0, (255, 0, 0), |
| line_width) |
| if debug: |
| its.image.write_image(img/255, img_name, True) |
| |
| print "Aspect ratio: %.3f" % aspect_ratio |
| print "Circle center position wrt to image center:", |
| print "%.3fx%.3f" % (cc_ct["vert"], cc_ct["hori"]) |
| return aspect_ratio, cc_ct, (circle_w, circle_h) |
| |
| |
| def main(): |
| """Test aspect ratio/field of view (FOV)/cropping for each tested formats combinations. |
| |
| This test checks for: |
| 1. Aspect ratio: images are not stretched |
| 2. Crop: center of images is always center of the image sensor no matter |
| how the image is cropped from sensor's full FOV |
| 3. FOV: images are always cropped to keep the maximum possible FOV with |
| only one dimension (horizontal or veritical) cropped. |
| |
| Aspect ratio and FOV test runs on level3, full and limited devices. |
| Crop test only runs on full and level3 devices. |
| |
| The test chart is a black circle inside a black square. When raw capture is |
| available, set the height vs. width ratio of the circle in the full-frame |
| raw as ground truth. In an ideal setup such ratio should be very close to |
| 1.0, but here we just use the value derived from full resolution RAW as |
| ground truth to account for the possiblity that the chart is not well |
| positioned to be precisely parallel to image sensor plane. |
| The test then compare the ground truth ratio with the same ratio measured |
| on images captued using different stream combinations of varying formats |
| ("jpeg" and "yuv") and resolutions. |
| If raw capture is unavailable, a full resolution JPEG image is used to setup |
| ground truth. In this case, the ground truth aspect ratio is defined as 1.0 |
| and it is the tester's responsibility to make sure the test chart is |
| properly positioned so the detected circles indeed have aspect ratio close |
| to 1.0 assuming no bugs causing image stretched. |
| |
| The aspect ratio test checks the aspect ratio of the detected circle and |
| it will fail if the aspect ratio differs too much from the ground truth |
| aspect ratio mentioned above. |
| |
| The FOV test examines the ratio between the detected circle area and the |
| image size. When the aspect ratio of the test image is the same as the |
| ground truth image, the ratio should be very close to the ground truth |
| value. When the aspect ratio is different, the difference is factored in |
| per the expectation of the Camera2 API specification, which mandates the |
| FOV reduction from full sensor area must only occur in one dimension: |
| horizontally or vertically, and never both. For example, let's say a sensor |
| has a 16:10 full sensor FOV. For all 16:10 output images there should be no |
| FOV reduction on them. For 16:9 output images the FOV should be vertically |
| cropped by 9/10. For 4:3 output images the FOV should be cropped |
| horizontally instead and the ratio (r) can be calculated as follows: |
| (16 * r) / 10 = 4 / 3 => r = 40 / 48 = 0.8333 |
| Say the circle is covering x percent of the 16:10 sensor on the full 16:10 |
| FOV, and assume the circle in the center will never be cut in any output |
| sizes (this can be achieved by picking the right size and position of the |
| test circle), the from above cropping expectation we can derive on a 16:9 |
| output image the circle will cover (x / 0.9) percent of the 16:9 image; on |
| a 4:3 output image the circle will cover (x / 0.8333) percent of the 4:3 |
| image. |
| |
| The crop test checks that the center of any output image remains aligned |
| with center of sensor's active area, no matter what kind of cropping or |
| scaling is applied. The test verified that by checking the relative vector |
| from the image center to the center of detected circle remains unchanged. |
| The relative part is normalized by the detected circle size to account for |
| scaling effect. |
| """ |
| aspect_ratio_gt = 1.0 # Ground truth circle width/height ratio. |
| # If full resolution RAW is available as reference |
| # then this will be updated to the value measured on |
| # the RAW image. Otherwise a full resolution JPEG |
| # will be used as reference and this value will be |
| # 1.0. |
| failed_ar = [] # streams failed the aspect ratio test |
| failed_crop = [] # streams failed the crop test |
| failed_fov = [] # streams that fail FoV test |
| format_list = [] # format list for multiple capture objects. |
| |
| # Do multi-capture of "iter" and "cmpr". Iterate through all the |
| # available sizes of "iter", and only use the size specified for "cmpr" |
| # The "cmpr" capture is only used so that we have multiple capture target |
| # instead of just one, which should help catching more potential issues. |
| # The test doesn't look into the output of "cmpr" images at all. |
| # The "iter_max" or "cmpr_size" key defines the maximal size being iterated |
| # or selected for the "iter" and "cmpr" stream accordingly. None means no |
| # upper bound is specified. |
| format_list.append({"iter": "yuv", "iter_max": None, |
| "cmpr": "yuv", "cmpr_size": PREVIEW_SIZE}) |
| format_list.append({"iter": "yuv", "iter_max": PREVIEW_SIZE, |
| "cmpr": "jpeg", "cmpr_size": None}) |
| format_list.append({"iter": "yuv", "iter_max": PREVIEW_SIZE, |
| "cmpr": "raw", "cmpr_size": None}) |
| format_list.append({"iter": "jpeg", "iter_max": None, |
| "cmpr": "raw", "cmpr_size": None}) |
| format_list.append({"iter": "jpeg", "iter_max": None, |
| "cmpr": "yuv", "cmpr_size": PREVIEW_SIZE}) |
| ref_fov = {} # Reference frame's FOV related information |
| # If RAW is available a full resolution RAW frame will be used |
| # as reference frame; otherwise the highest resolution JPEG is used. |
| with its.device.ItsSession() as cam: |
| props = cam.get_camera_properties() |
| fls_logical = props['android.lens.info.availableFocalLengths'] |
| print 'logical available focal lengths: %s', str(fls_logical) |
| props = cam.override_with_hidden_physical_camera_props(props) |
| fls_physical = props['android.lens.info.availableFocalLengths'] |
| print 'physical available focal lengths: %s', str(fls_physical) |
| # determine skip conditions |
| first_api = its.device.get_first_api_level(its.device.get_device_id()) |
| if first_api < 30: # original constraint |
| its.caps.skip_unless(its.caps.read_3a(props)) |
| else: # loosen from read_3a to enable LIMITED coverage |
| its.caps.skip_unless(its.caps.ae_lock(props) and |
| its.caps.awb_lock(props)) |
| # determine capabilities |
| full_device = its.caps.full_or_better(props) |
| limited_device = its.caps.limited(props) |
| its.caps.skip_unless(full_device or limited_device) |
| level3_device = its.caps.level3(props) |
| raw_avlb = its.caps.raw16(props) |
| run_crop_test = (level3_device or full_device) and raw_avlb |
| if not run_crop_test: |
| print "Crop test skipped" |
| debug = its.caps.debug_mode() |
| # Converge 3A |
| cam.do_3a() |
| req = its.objects.auto_capture_request() |
| |
| # If raw is available and main camera, use it as ground truth. |
| if raw_avlb and (fls_physical == fls_logical): |
| ref_fov, cc_ct_gt, aspect_ratio_gt = find_raw_fov_reference(cam, req, props, debug) |
| else: |
| ref_fov, cc_ct_gt = find_jpeg_fov_reference(cam, req, props) |
| |
| if run_crop_test: |
| # Normalize the circle size to 1/4 of the image size, so that |
| # circle size won't affect the crop test result |
| factor_cp_thres = ((min(ref_fov["w"], ref_fov["h"])/4.0) / |
| max(ref_fov["circle_w"], ref_fov["circle_h"])) |
| thres_l_cp_test = THRESH_L_CP * factor_cp_thres |
| thres_xs_cp_test = THRESH_XS_CP * factor_cp_thres |
| |
| # Take pictures of each settings with all the image sizes available. |
| for fmt in format_list: |
| fmt_iter = fmt["iter"] |
| fmt_cmpr = fmt["cmpr"] |
| dual_target = fmt_cmpr is not "none" |
| # Get the size of "cmpr" |
| if dual_target: |
| sizes = its.objects.get_available_output_sizes( |
| fmt_cmpr, props, fmt["cmpr_size"]) |
| if not sizes: # device might not support RAW |
| continue |
| size_cmpr = sizes[0] |
| for size_iter in its.objects.get_available_output_sizes( |
| fmt_iter, props, fmt["iter_max"]): |
| w_iter = size_iter[0] |
| h_iter = size_iter[1] |
| # Skip testing same format/size combination |
| # ITS does not handle that properly now |
| if (dual_target |
| and w_iter*h_iter == size_cmpr[0]*size_cmpr[1] |
| and fmt_iter == fmt_cmpr): |
| continue |
| out_surface = [{"width": w_iter, |
| "height": h_iter, |
| "format": fmt_iter}] |
| if dual_target: |
| out_surface.append({"width": size_cmpr[0], |
| "height": size_cmpr[1], |
| "format": fmt_cmpr}) |
| cap = cam.do_capture(req, out_surface) |
| if dual_target: |
| frm_iter = cap[0] |
| else: |
| frm_iter = cap |
| assert frm_iter["format"] == fmt_iter |
| assert frm_iter["width"] == w_iter |
| assert frm_iter["height"] == h_iter |
| print "Captured %s with %s %dx%d. Compared size: %dx%d" % ( |
| fmt_iter, fmt_cmpr, w_iter, h_iter, size_cmpr[0], |
| size_cmpr[1]) |
| img = its.image.convert_capture_to_rgb_image(frm_iter) |
| img_name = "%s_%s_with_%s_w%d_h%d.png" % (NAME, |
| fmt_iter, fmt_cmpr, |
| w_iter, h_iter) |
| aspect_ratio, cc_ct, (cc_w, cc_h) = measure_aspect_ratio( |
| img, img_name, raw_avlb, debug) |
| # check fov coverage for all fmts in AR_CHECKED |
| fov_percent = calc_circle_image_ratio( |
| cc_w, cc_h, w_iter, h_iter) |
| chk_percent = calc_expected_circle_image_ratio(ref_fov, w_iter, h_iter) |
| chk_enabled = is_checked_aspect_ratio(first_api, w_iter, h_iter) |
| if chk_enabled and not np.isclose(fov_percent, chk_percent, |
| rtol=FOV_PERCENT_RTOL): |
| msg = "FoV %%: %.2f, Ref FoV %%: %.2f, " % ( |
| fov_percent, chk_percent) |
| msg += "TOL=%.f%%, img: %dx%d, ref: %dx%d" % ( |
| FOV_PERCENT_RTOL*100, w_iter, h_iter, |
| ref_fov["w"], ref_fov["h"]) |
| failed_fov.append(msg) |
| its.image.write_image(img/255, img_name, True) |
| |
| # check pass/fail for aspect ratio |
| # image size: the larger one of image width and height |
| # image size >= LARGE_SIZE: use THRESH_L_AR |
| # image size == 0 (extreme case): THRESH_XS_AR |
| # 0 < image size < LARGE_SIZE: scale between THRESH_XS_AR |
| # and THRESH_L_AR |
| thres_ar_test = max( |
| THRESH_L_AR, THRESH_XS_AR + max(w_iter, h_iter) * |
| (THRESH_L_AR-THRESH_XS_AR)/LARGE_SIZE) |
| thres_range_ar = (aspect_ratio_gt-thres_ar_test, |
| aspect_ratio_gt+thres_ar_test) |
| if (aspect_ratio < thres_range_ar[0] or |
| aspect_ratio > thres_range_ar[1]): |
| failed_ar.append({"fmt_iter": fmt_iter, |
| "fmt_cmpr": fmt_cmpr, |
| "w": w_iter, "h": h_iter, |
| "ar": aspect_ratio, |
| "valid_range": thres_range_ar}) |
| its.image.write_image(img/255, img_name, True) |
| |
| # check pass/fail for crop |
| if run_crop_test: |
| # image size >= LARGE_SIZE: use thres_l_cp_test |
| # image size == 0 (extreme case): thres_xs_cp_test |
| # 0 < image size < LARGE_SIZE: scale between |
| # thres_xs_cp_test and thres_l_cp_test |
| # Also, allow at least THRESH_MIN_PIXEL off to |
| # prevent threshold being too tight for very |
| # small circle |
| thres_hori_cp_test = max( |
| thres_l_cp_test, thres_xs_cp_test + w_iter * |
| (thres_l_cp_test-thres_xs_cp_test)/LARGE_SIZE) |
| min_threshold_h = THRESH_MIN_PIXEL / cc_w |
| thres_hori_cp_test = max(thres_hori_cp_test, |
| min_threshold_h) |
| thres_range_h_cp = (cc_ct_gt["hori"]-thres_hori_cp_test, |
| cc_ct_gt["hori"]+thres_hori_cp_test) |
| thres_vert_cp_test = max( |
| thres_l_cp_test, thres_xs_cp_test + h_iter * |
| (thres_l_cp_test-thres_xs_cp_test)/LARGE_SIZE) |
| min_threshold_v = THRESH_MIN_PIXEL / cc_h |
| thres_vert_cp_test = max(thres_vert_cp_test, |
| min_threshold_v) |
| thres_range_v_cp = (cc_ct_gt["vert"]-thres_vert_cp_test, |
| cc_ct_gt["vert"]+thres_vert_cp_test) |
| if (cc_ct["hori"] < thres_range_h_cp[0] |
| or cc_ct["hori"] > thres_range_h_cp[1] |
| or cc_ct["vert"] < thres_range_v_cp[0] |
| or cc_ct["vert"] > thres_range_v_cp[1]): |
| failed_crop.append({"fmt_iter": fmt_iter, |
| "fmt_cmpr": fmt_cmpr, |
| "w": w_iter, "h": h_iter, |
| "ct_hori": cc_ct["hori"], |
| "ct_vert": cc_ct["vert"], |
| "valid_range_h": thres_range_h_cp, |
| "valid_range_v": thres_range_v_cp}) |
| its.image.write_image(img/255, img_name, True) |
| |
| # Print failed any test results |
| print_failed_test_results(failed_ar, failed_fov, failed_crop) |
| assert not failed_ar |
| assert not failed_fov |
| if level3_device: |
| assert not failed_crop |
| |
| |
| if __name__ == "__main__": |
| main() |
