# 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 math
import os.path
import cv2
import its.caps
import its.device
import its.image
import its.objects
import numpy as np

FMT_ATOL = 0.01  # Absolute tolerance on format ratio
AR_CHECKED = ["4:3", "16:9", "18:9"]  # Aspect ratios checked
FOV_PERCENT_RTOL = 0.15  # Relative tolerance on circle FoV % to expected
LARGE_SIZE = 2000   # Define the size of a large image
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


def convert_ar_to_float(ar_string):
    """Convert aspect ratio string into float.

    Args:
        ar_string:  "4:3" or "16:9"
    Returns:
        float(ar_string)
    """
    ar_list = [float(x) for x in ar_string.split(":")]
    return ar_list[0] / ar_list[1]


def determine_sensor_aspect_ratio(props):
    """Determine the aspect ratio of the sensor.

    Args:
        props:      camera properties
    Returns:
        matched entry in AR_CHECKED
    """
    match_ar = None
    sensor_size = props["android.sensor.info.preCorrectionActiveArraySize"]
    sensor_ar = (float(abs(sensor_size["right"] - sensor_size["left"])) /
                 abs(sensor_size["bottom"] - sensor_size["top"]))
    for ar_string in AR_CHECKED:
        if np.isclose(sensor_ar, convert_ar_to_float(ar_string), atol=FMT_ATOL):
            match_ar = ar_string
    if not match_ar:
        print "Warning! RAW aspect ratio not in:", AR_CHECKED
    return match_ar


def aspect_ratio_scale_factors(ref_ar_string, props):
    """Determine scale factors for each aspect ratio to correct cropping.

    Args:
        ref_ar_string:      camera aspect ratio that is the reference
        props:              camera properties
    Returns:
        dict of correction ratios with AR_CHECKED values as keys
    """
    ref_ar = convert_ar_to_float(ref_ar_string)

    # find sensor area
    height_max = 0
    width_max = 0
    for ar_string in AR_CHECKED:
        match_ar = [float(x) for x in ar_string.split(":")]
        try:
            f = its.objects.get_largest_yuv_format(props, match_ar=match_ar)
            if f["height"] > height_max:
                height_max = f["height"]
            if f["width"] > width_max:
                width_max = f["width"]
        except IndexError:
            continue
    sensor_ar = float(width_max) / height_max

    # apply scaling
    ar_scaling = {}
    for ar_string in AR_CHECKED:
        target_ar = convert_ar_to_float(ar_string)
        # scale down to sensor with greater (or equal) dims
        if ref_ar >= sensor_ar:
            scaling = sensor_ar / ref_ar
        else:
            scaling = ref_ar / sensor_ar

        # scale up due to cropping to other format
        if target_ar >= sensor_ar:
            scaling = scaling * target_ar / sensor_ar
        else:
            scaling = scaling * sensor_ar / target_ar

        ar_scaling[ar_string] = scaling
    return ar_scaling


def find_yuv_fov_reference(cam, req, props):
    """Determine the circle coverage of the image in YUV reference image.

    Args:
        cam:        camera object
        req:        camera request
        props:      camera properties

    Returns:
        ref_fov:    dict with [fmt, % coverage, w, h]
    """
    ref_fov = {}
    fmt_dict = {}

    # find number of pixels in different formats
    for ar in AR_CHECKED:
        match_ar = [float(x) for x in ar.split(":")]
        try:
            f = its.objects.get_largest_yuv_format(props, match_ar=match_ar)
            fmt_dict[f["height"]*f["width"]] = {"fmt": f, "ar": ar}
        except IndexError:
            continue

    # use image with largest coverage as reference
    ar_max_pixels = max(fmt_dict, key=int)

    # capture and determine circle area in image
    cap = cam.do_capture(req, fmt_dict[ar_max_pixels]["fmt"])
    w = cap["width"]
    h = cap["height"]
    img = its.image.convert_capture_to_rgb_image(cap, props=props)
    print "Captured %s %dx%d" % ("yuv", w, h)
    img_name = "%s_%s_w%d_h%d.png" % (NAME, "yuv", w, h)
    _, _, circle_size = measure_aspect_ratio(img, False, img_name, True)
    fov_percent = calc_circle_image_ratio(circle_size[1], circle_size[0], w, h)
    ref_fov["fmt"] = fmt_dict[ar_max_pixels]["ar"]
    ref_fov["percent"] = fov_percent
    ref_fov["w"] = w
    ref_fov["h"] = h
    print "Using YUV reference:", ref_fov
    return ref_fov


def calc_circle_image_ratio(circle_w, circle_h, image_w, image_h):
    """Calculate the circle coverage of the 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 main():
    """Test aspect ratio & check if images are cropped correctly for each fmt.

    Aspect ratio test runs on level3, full and limited devices. Crop test only
    runs on full and level3 devices.
    The test image 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. Then compare with images of request combinations of
    different formats ("jpeg" and "yuv") and sizes.
    If raw capture is unavailable, take a picture of the test image right in
    front to eliminate shooting angle effect. the height vs. width ratio for
    the circle should be close to 1. Considering shooting position error, aspect
    ratio greater than 1+THRESH_*_AR or less than 1-THRESH_*_AR will FAIL.
    """
    aspect_ratio_gt = 1  # ground truth
    failed_ar = []  # streams failed the aspect ration test
    failed_crop = []  # streams failed the crop 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"
    # Do single-capture to cover untouched sizes in multi-capture when needed.
    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 = {}
    with its.device.ItsSession() as cam:
        props = cam.get_camera_properties()
        its.caps.skip_unless(its.caps.read_3a(props))
        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)
        mono_camera = its.caps.mono_camera(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 and get the estimates.
        sens, exp, gains, xform, focus = cam.do_3a(get_results=True,
                                                   lock_ae=True, lock_awb=True,
                                                   mono_camera=mono_camera)
        print "AE sensitivity %d, exposure %dms" % (sens, exp / 1000000.0)
        print "AWB gains", gains
        print "AWB transform", xform
        print "AF distance", focus
        req = its.objects.manual_capture_request(
                sens, exp, focus, True, props)
        xform_rat = its.objects.float_to_rational(xform)
        req["android.colorCorrection.gains"] = gains
        req["android.colorCorrection.transform"] = xform_rat

        # If raw capture is available, use it as ground truth.
        if raw_avlb:
            # Capture full-frame raw. Use its aspect ratio and circle center
            # location as ground truth for the other jepg 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)
            if its.caps.distortion_correction(props):
                # The intrinsics and distortion coefficients are meant for full
                # size RAW. Resize back to full size here.
                img_raw = cv2.resize(img_raw, (0,0), fx=2.0, fy=2.0)
                # 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(props["android.lens.info.availableFocalLengths"][0])
                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)
            aspect_ratio_gt, cc_ct_gt, circle_size_raw = measure_aspect_ratio(
                    img_raw, raw_avlb, img_name, debug)
            raw_fov_percent = calc_circle_image_ratio(
                    circle_size_raw[1], circle_size_raw[0], w_raw, h_raw)
            # 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(size_raw[0:1])/4.0) / max(circle_size_raw)
            thres_l_cp_test = THRESH_L_CP * factor_cp_thres
            thres_xs_cp_test = THRESH_XS_CP * factor_cp_thres
            # If RAW in AR_CHECKED, use it as reference
            ref_fov["fmt"] = determine_sensor_aspect_ratio(props)
            if ref_fov["fmt"]:
                ref_fov["percent"] = raw_fov_percent
                ref_fov["w"] = w_raw
                ref_fov["h"] = h_raw
                print "Using RAW reference:", ref_fov
            else:
                ref_fov = find_yuv_fov_reference(cam, req, props)
        else:
            ref_fov = find_yuv_fov_reference(cam, req, props)

        # Determine scaling factors for AR calculations
        ar_scaling = aspect_ratio_scale_factors(ref_fov["fmt"], props)

        # 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 == size_cmpr[0]
                            and h_iter == 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)
                if its.caps.distortion_correction(props) and raw_avlb:
                    w_scale = float(w_iter)/w_raw
                    h_scale = float(h_iter)/h_raw
                    k_scale = np.array([[ical[0]*w_scale, ical[4],
                                         ical[2]*w_scale],
                                        [0, ical[1]*h_scale, ical[3]*h_scale],
                                        [0, 0, 1]])
                    print "k_scale:", k_scale
                    img = cv2.undistort(img, k_scale, opencv_dist)
                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, raw_avlb, img_name, debug)
                # check fov coverage for all fmts in AR_CHECKED
                fov_percent = calc_circle_image_ratio(
                        cc_w, cc_h, w_iter, h_iter)
                for ar_check in AR_CHECKED:
                    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_iter)/h_iter, match_ar,
                                  atol=FMT_ATOL):
                        # scale check value based on aspect ratio
                        chk_percent = ref_fov["percent"] * ar_scaling[ar_check]

                        msg = "FoV %%: %.2f, Ref FoV %%: %.2f, TOL=%.f%%, " % (
                                fov_percent, chk_percent,
                                FOV_PERCENT_RTOL*100)
                        msg += "img: %dx%d, ref: %dx%d" % (w_iter, h_iter,
                                                           ref_fov["w"],
                                                           ref_fov["h"])
                        assert np.isclose(fov_percent, chk_percent,
                                          rtol=FOV_PERCENT_RTOL), msg
                # check pass/fail for aspect ratio
                # 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 aspect ratio test results
        failed_image_number_for_aspect_ratio_test = len(failed_ar)
        if failed_image_number_for_aspect_ratio_test > 0:
            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])

        # Print crop test results
        failed_image_number_for_crop_test = len(failed_crop)
        if failed_image_number_for_crop_test > 0:
            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])

        assert failed_image_number_for_aspect_ratio_test == 0
        if level3_device:
            assert failed_image_number_for_crop_test == 0


def measure_aspect_ratio(img, raw_avlb, img_name, 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].
        raw_avlb: True: raw capture is available; False: raw capture is not
             available.
        img_name: string with image info of format and size.
        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("2.4."):
        contours, hierarchy = cv2.findContours(255-img_bw, cv2.RETR_TREE,
                                               cv2.CHAIN_APPROX_SIMPLE)
    elif cv2_version.startswith("3.2."):
        _, 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 = component_shape(ct)
        parent = hrch[3]
        prt_shape = 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 is a black, and Parent is white
        # 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 component_shape(contour):
    """Measure the shape for a connected component in the aspect ratio test.

    Args:
        contour: return from cv2.findContours. A list of pixel coordinates of
        the contour.

    Returns:
        The most left, right, top, bottom pixel location, height, width, and
        the center pixel location of the contour.
    """
    shape = {"left": np.inf, "right": 0, "top": np.inf, "bottom": 0,
             "width": 0, "height": 0, "ctx": 0, "cty": 0}
    for pt in contour:
        if pt[0][0] < shape["left"]:
            shape["left"] = pt[0][0]
        if pt[0][0] > shape["right"]:
            shape["right"] = pt[0][0]
        if pt[0][1] < shape["top"]:
            shape["top"] = pt[0][1]
        if pt[0][1] > shape["bottom"]:
            shape["bottom"] = pt[0][1]
    shape["width"] = shape["right"] - shape["left"] + 1
    shape["height"] = shape["bottom"] - shape["top"] + 1
    shape["ctx"] = (shape["left"]+shape["right"])/2
    shape["cty"] = (shape["top"]+shape["bottom"])/2
    return shape


if __name__ == "__main__":
    main()