test

horizonmetrics.py

@@ -16,7 +16,7 @@
 import evaluate
 import datasets
 
-from seametrics.horizon.utils import *
+#from seametrics.horizon.utils import *
 
 # TODO: Add BibTeX citation
 _CITATION = """\
@@ -59,6 +59,273 @@ BAD_WORDS_URL = "http://url/to/external/resource/bad_words.txt"
 
 @evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION,
                                                 _KWARGS_DESCRIPTION)
+
+# begin utils
+import numpy as np
+
+
+def xy_points_to_slope_midpoint(xy_points):
+    """
+    Given two points, return the slope and midpoint of the line
+
+    Args:
+    xy_points: list of two points, each point is a list of two elements
+    Points are in the form of [x, y], where x and y are normalized to [0, 1]
+
+    Returns:
+    slope: Slope of the line
+    midpoint : Midpoint is in the form of [x,y], and is also normalized to [0, 1]
+    """
+
+    #x1, y1, x2, y2 = xy_points[0][0], xy_points[0][1], xy_points[1][
+    #    0], xy_points[1][1]
+
+    x1, y1, x2, y2 = xy_points[0], xy_points[1], xy_points[2], xy_points[3]
+    slope = (y2 - y1) / (x2 - x1)
+
+    midpoint_x = 0.5
+    midpoint_y = slope * (0.5 - x1) + y1
+    midpoint = [midpoint_x, midpoint_y]
+    return slope, midpoint
+
+
+def calculate_horizon_error(annotated_horizon, proposed_horizon):
+    """
+    Calculate the error between the annotated horizon and the proposed horizon
+
+    Args:
+    annotated_horizon: list of two points, each point is a list of two elements
+    Points are in the form of [x, y], where x and y are normalized to [0, 1]
+    proposed_horizon: list of two points, each point is a list of two elements
+    Points are in the form of [x, y], where x and y are normalized to [0, 1]
+
+    Returns:
+    slope_error: Error in the slope of the lines
+    midpoint_error: Error in the midpoint_y of the lines
+    """
+
+    slope_annotated, midpoint_annotated = xy_points_to_slope_midpoint(
+        annotated_horizon)
+    slope_proposed, midpoint_proposed = xy_points_to_slope_midpoint(
+        proposed_horizon)
+
+    slope_error = abs(slope_annotated - slope_proposed)
+    midpoint_error = abs(midpoint_annotated[1] - midpoint_proposed[1])
+
+    return slope_error, midpoint_error
+
+
+def calculate_horizon_error_across_sequence(slope_error_list,
+                                            midpoint_error_list,
+                                            slope_error_jump_threshold,
+                                            midpoint_error_jump_threshold):
+    """
+    Calculate the error statistics across a sequence of frames
+
+    Args:
+    slope_error_list: List of errors in the slope of the lines
+    midpoint_error_list: List of errors in the midpoint_y of the lines
+
+    Returns:
+    average_slope_error: Average error in the slope of the lines
+    average_midpoint_error: Average error in the midpoint_y of the lines
+    """
+
+    # Calculate the average and standard deviation of the errors
+    average_slope_error = np.mean(slope_error_list)
+    average_midpoint_error = np.mean(midpoint_error_list)
+
+    stddev_slope_error = np.std(slope_error_list)
+    stddev_midpoint_error = np.std(midpoint_error_list)
+
+    # Calculate the maximum errors
+    max_slope_error = np.max(slope_error_list)
+    max_midpoint_error = np.max(midpoint_error_list)
+
+    # Calculate the differences between errors in successive frames
+    diff_slope_error = np.abs(np.diff(slope_error_list))
+    diff_midpoint_error = np.abs(np.diff(midpoint_error_list))
+
+    # Calculate the number of jumps in the errors
+    num_slope_error_jumps = np.sum(
+        diff_slope_error > slope_error_jump_threshold)
+    num_midpoint_error_jumps = np.sum(
+        diff_midpoint_error > midpoint_error_jump_threshold)
+
+    # Create a dictionary to store the results
+    sequence_results = {
+        'average_slope_error': average_slope_error,
+        'average_midpoint_error': average_midpoint_error,
+        'stddev_slope_error': stddev_slope_error,
+        'stddev_midpoint_error': stddev_midpoint_error,
+        'max_slope_error': max_slope_error,
+        'max_midpoint_error': max_midpoint_error,
+        'num_slope_error_jumps': num_slope_error_jumps,
+        'num_midpoint_error_jumps': num_midpoint_error_jumps
+    }
+
+    return sequence_results
+
+
+def xy_points_to_slope_midpoint(xy_points):
+    """
+    Given two points, return the slope and midpoint of the line
+
+    Args:
+    xy_points: list of two points, each point is a list of two elements
+    Points are in the form of [x, y], where x and y are normalized to [0, 1]
+
+    Returns:
+    slope: Slope of the line
+    midpoint : Midpoint is in the form of [x,y], and is also normalized to [0, 1]
+    """
+
+    x1, y1, x2, y2 = xy_points[0][0], xy_points[0][1], xy_points[1][
+        0], xy_points[1][1]
+    slope = (y2 - y1) / (x2 - x1)
+
+    midpoint_x = 0.5
+    midpoint_y = slope * (0.5 - x1) + y1
+    midpoint = [midpoint_x, midpoint_y]
+    return slope, midpoint
+
+
+def calculate_horizon_error(annotated_horizon, proposed_horizon):
+    """
+    Calculate the error between the annotated horizon and the proposed horizon
+
+    Args:
+    annotated_horizon: list of two points, each point is a list of two elements
+    Points are in the form of [x, y], where x and y are normalized to [0, 1]
+    proposed_horizon: list of two points, each point is a list of two elements
+    Points are in the form of [x, y], where x and y are normalized to [0, 1]
+
+    Returns:
+    slope_error: Error in the slope of the lines
+    midpoint_error: Error in the midpoint_y of the lines
+    """
+
+    slope_annotated, midpoint_annotated = xy_points_to_slope_midpoint(
+        annotated_horizon)
+    slope_proposed, midpoint_proposed = xy_points_to_slope_midpoint(
+        proposed_horizon)
+
+    slope_error = abs(slope_annotated - slope_proposed)
+    midpoint_error = abs(midpoint_annotated[1] - midpoint_proposed[1])
+
+    return slope_error, midpoint_error
+
+
+def calculate_horizon_error_across_sequence(slope_error_list,
+                                            midpoint_error_list,
+                                            slope_error_jump_threshold,
+                                            midpoint_error_jump_threshold):
+    """
+    Calculate the error statistics across a sequence of frames
+
+    Args:
+    slope_error_list: List of errors in the slope of the lines
+    midpoint_error_list: List of errors in the midpoint_y of the lines
+
+    Returns:
+    average_slope_error: Average error in the slope of the lines
+    average_midpoint_error: Average error in the midpoint_y of the lines
+    """
+
+    # Calculate the average and standard deviation of the errors
+    average_slope_error = np.mean(slope_error_list)
+    average_midpoint_error = np.mean(midpoint_error_list)
+
+    stddev_slope_error = np.std(slope_error_list)
+    stddev_midpoint_error = np.std(midpoint_error_list)
+
+    # Calculate the maximum errors
+    max_slope_error = np.max(slope_error_list)
+    max_midpoint_error = np.max(midpoint_error_list)
+
+    # Calculate the differences between errors in successive frames
+    diff_slope_error = np.abs(np.diff(slope_error_list))
+    diff_midpoint_error = np.abs(np.diff(midpoint_error_list))
+
+    # Calculate the number of jumps in the errors
+    num_slope_error_jumps = np.sum(
+        diff_slope_error > slope_error_jump_threshold)
+    num_midpoint_error_jumps = np.sum(
+        diff_midpoint_error > midpoint_error_jump_threshold)
+
+    # Create a dictionary to store the results
+    sequence_results = {
+        'average_slope_error': average_slope_error,
+        'average_midpoint_error': average_midpoint_error,
+        'stddev_slope_error': stddev_slope_error,
+        'stddev_midpoint_error': stddev_midpoint_error,
+        'max_slope_error': max_slope_error,
+        'max_midpoint_error': max_midpoint_error,
+        'num_slope_error_jumps': num_slope_error_jumps,
+        'num_midpoint_error_jumps': num_midpoint_error_jumps
+    }
+
+    return sequence_results
+
+
+def slope_to_roll(slope):
+    """
+    Convert the slope of the horizon to roll
+
+    Args:
+    slope: Slope of the horizon
+
+    Returns:
+    roll: Roll in degrees
+    """
+    roll = np.arctan(slope) * 180 / np.pi
+    return roll
+
+
+def roll_to_slope(roll):
+    """
+    Convert the roll of the horizon to slope
+
+    Args:
+    roll: Roll of the horizon in degrees
+
+    Returns:
+    slope: Slope of the horizon
+    """
+    slope = np.tan(roll * np.pi / 180)
+    return slope
+
+
+def midpoint_to_pitch(midpoint, vertical_fov_degrees):
+    """
+    Convert the midpoint of the horizon to pitch
+
+    Args:
+    midpoint: Midpoint of the horizon
+    vertical_fov_degrees: Vertical field of view of the camera in degrees
+
+    Returns:
+    pitch: Pitch in degrees
+    """
+    pitch = midpoint * vertical_fov_degrees
+    return pitch
+
+
+def pitch_to_midpoint(pitch, vertical_fov_degrees):
+    """
+    Convert the pitch of the horizon to midpoint
+
+    Args:
+    pitch: Pitch of the horizon in degrees
+    vertical_fov_degrees: Vertical field of view of the camera in degrees
+
+    Returns:
+    midpoint: Midpoint of the horizon
+    """
+    midpoint = pitch / vertical_fov_degrees
+    return midpoint
+
+# end utils
 class horizonmetrics(evaluate.Metric):
     """TODO: Short description of my evaluation module."""