Pool Cover

""" Plot the shape of a pool using AB measurements technique. """

from dataclasses import dataclass
import json
import numpy as np
import matplotlib.pyplot as plt
from typing import List, Tuple


@dataclass
class ReferencePoints:
    start_label  : str
    end_label    : str
    distance     : float
    
    @classmethod
    def from_tuple_data( cls, tuple_data : Tuple[ str, str, int, float ] ):
        return ReferencePoints(
            start_label = tuple_data[0],
            end_label = tuple_data[1],
            distance = ( tuple_data[2] * 12 ) + tuple_data[3],
        )
    
    def plot( self ):
        plt.scatter( [ 0, self.distance ], [0, 0], color='red', s=100 )
        plt.text( -16, 0, self.start_label,
                  fontsize = 24, fontweight='bold',
                  color='red', verticalalignment='bottom')
        plt.text( self.distance + 8, 0, self.end_label,
                  fontsize=24, fontweight='bold',
                  color='red', verticalalignment='bottom')
        return
        
        
@dataclass
class PointPlotter:
    measurement_data     : List[ Tuple[ str, str, int, float ]]
    reference_points     : ReferencePoints

    def __post_init__(self):
        self.triangulated_points = self.triangulate()        
        self.sorted_labels = sorted( self.triangulated_points.keys(), key=lambda x: int(x) )
        self.sorted_points = np.array([ self.triangulated_points[label] for label in self.sorted_labels ])
        return

    def plot_extents(self):
        x_min, x_max = min(self.sorted_points[:, 0]), max(self.sorted_points[:, 0])
        y_min, y_max = min(self.sorted_points[:, 1]), max(self.sorted_points[:, 1])
        return ( x_min, y_min, x_max, y_max )
    
    def plot_points(self, color : str = 'blue' ):
        plt.scatter(self.sorted_points[:, 0], self.sorted_points[:, 1], color=color)
        return

    def plot_labels( self, position_inside : bool = True ):
        if position_inside:
            # Sort the points by numeric label to ensure correct ordering
            # (sorted in clockwise order)
            sorted_by_label_points = [ self.triangulated_points[label] for label in self.sorted_labels ]

            for idx, label in enumerate(self.sorted_labels):
                x, y = self.triangulated_points[label]
                offset_x, offset_y = self.get_outward_offset( idx, sorted_by_label_points )
                plt.text( x + offset_x, y + offset_y, label, fontsize=10,
                          verticalalignment='center', horizontalalignment='center' )
                continue
        else:
            label_offset = 7
            for idx, label in enumerate(self.sorted_labels):
                # Get current vertex and its two neighboring points
                p_prev = self.sorted_points[idx - 1]  # Previous point
                p_curr = self.sorted_points[idx]      # Current vertex
                p_next = self.sorted_points[(idx + 1) % len(self.sorted_points)]  # Next point

                # Compute outward normal for each adjacent edge
                dx1, dy1 = p_curr[0] - p_prev[0], p_curr[1] - p_prev[1]
                dx2, dy2 = p_next[0] - p_curr[0], p_next[1] - p_curr[1]

                # Compute normals (-dy, dx) for both edges
                norm1 = np.array([-dy1, dx1]) / np.sqrt(dx1**2 + dy1**2)
                norm2 = np.array([-dy2, dx2]) / np.sqrt(dx2**2 + dy2**2)

                # Compute average outward normal (normalized)
                outward = (norm1 + norm2) / 2
                outward /= np.linalg.norm(outward)  # Normalize to maintain consistent scaling

                # Compute label position by offsetting in outward direction
                label_x = p_curr[0] + outward[0] * label_offset
                label_y = p_curr[1] + outward[1] * label_offset

                # Place label diagonally from vertex
                plt.text(label_x, label_y, label, ha='center', va='center', fontsize=10, color="red")
                continue
        return

    def plot_curves(self):
        # Draw piecewise Bézier curves

        for i in range(len(self.sorted_points) - 2):
            x_curve, y_curve = self.quadratic_bezier( self.sorted_points[i],
                                                      self.sorted_points[i + 1],
                                                      self.sorted_points[i + 2] )
            plt.plot(x_curve, y_curve, 'g-', alpha=0.7)
            continue
        
        # Close the shape by interpolating between the last and first points
        x_curve, y_curve = self.quadratic_bezier( self.sorted_points[-2],
                                                  self.sorted_points[-1],
                                                  self.sorted_points[0] )
        plt.plot(x_curve, y_curve, 'g-', alpha=0.7)
        
        return

    def plot_lines( self, color : str ):
        closed_points = np.vstack([self.sorted_points, self.sorted_points[0]])  # Add first point at the end
        x, y = closed_points[:, 0], closed_points[:, 1]
        plt.plot( x, y, marker="o", linestyle="-", color = color )  # Draw lines between points
        return
    
    def plot_errors( self,
                     error_check_measurement_data : List[ Tuple[ str, str, int, float ]],
                     error_threshold : float ):
        for p1, p2, feet, inches in error_check_measurement_data:
            if p1 in self.triangulated_points and p2 in self.triangulated_points:
                # Compute expected and actual distances
                measured_distance = (feet * 12) + inches
                computed_distance = np.linalg.norm( np.array(self.triangulated_points[p1])
                                                    - np.array(self.triangulated_points[p2]) )
                error = abs(computed_distance - measured_distance)

                # Highlight points with significant error
                mid_x = (self.triangulated_points[p1][0] + self.triangulated_points[p2][0]) / 2
                mid_y = (self.triangulated_points[p1][1] + self.triangulated_points[p2][1]) / 2

                if error > error_threshold:
                    plt.text( mid_x, mid_y, f"Error: {error:.1f}\"",
                              fontsize=8, color="red", fontweight='bold' )
                    plt.plot([ self.triangulated_points[p1][0], self.triangulated_points[p2][0] ],
                             [ self.triangulated_points[p1][1], self.triangulated_points[p2][1] ],
                             'r--', alpha=0.5, label="High Error"
                             if 'High Error' not in plt.gca().get_legend_handles_labels()[1] else "")
            continue
        return
    
    def triangulate( self ):
        end_ref_distances = {}
        start_ref_distances = {}

        for reference_label, point_label, feet, inches in self.measurement_data:
            total_inches = ( feet * 12 ) + inches
            if reference_label == self.reference_points.end_label:
                end_ref_distances[point_label] = total_inches
            else:
                start_ref_distances[point_label] = total_inches
            continue

        # Compute coordinates of plotted points using triangulation
        plot_points = {}

        for label in end_ref_distances.keys() & start_ref_distances.keys():
            a = end_ref_distances[label]
            b = start_ref_distances[label]
            c = self.reference_points.distance

            # Law of cosines: cos(A) = (b² + c² - a²) / (2bc)
            cos_A = ( b**2 + c**2 - a**2 ) / ( 2 * b * c )
            cos_A = np.clip(cos_A, -1, 1)  # Avoid rounding errors
            angle_A = np.arccos( cos_A )  # Angle in radians

            # Convert to new coordinate system: start is (0,0), end is at (reference_distance, 0)
            x = b * np.cos( angle_A )
            y = b * np.sin( angle_A )
            plot_points[label] = (x, y)
            continue
        return plot_points

    def get_outward_offset( self, idx, points, offset_dist = 10 ):
        """Compute outward offset using tangent vector and 90-degree rotation."""
        num_points = len(points)
        next_idx = (idx + 1) % num_points  # Next point in sequence (wrap around)

        # Compute tangent vector (pointing along shape perimeter)
        tangent = np.array(points[next_idx]) - np.array(points[idx])

        # Compute outward normal by rotating tangent -90 degrees (clockwise normal)
        normal = np.array([tangent[1], -tangent[0]])  # Rotate tangent 90° clockwise

        # Normalize and scale outward
        normal = normal / np.linalg.norm(normal) * offset_dist

        return normal[0], normal[1]

    def quadratic_bezier( self, p1, p2, p3, num = 30 ):
        """Generate points for a piecewise quadratic Bézier curve between p1, p2 (control), and p3."""
        t = np.linspace(0, 1, num)[:, np.newaxis]  # Ensure t is column vector for broadcasting
        p1, p2, p3 = map(np.array, [p1, p2, p3])  # Convert tuples to NumPy arrays
        curve = (1 - t)**2 * p1 + 2 * (1 - t) * t * p2 + t**2 * p3
        return curve[:, 0], curve[:, 1]  # Return x and y values separately
    

if __name__ == '__main__':

    error_checking_enabled = False
    obstruction_closeup = False

    data_filename = 'pool-measurements.json'
    plot_scale_factor = 1.30
    error_threshold = 0.5  # Inches
    margin = 5
    
    with open( data_filename, 'r' ) as fh:
        data = json.load( fh )

    reference_points = ReferencePoints.from_tuple_data(
        tuple_data = data['reference_points'],
    )
    pool_edge_measurement_data = data['pool_edge_points']
    error_check_measurement_data = data['diagonals']

    obstruction_measurement_data_list = [
        data[x] for x in [ 'ladder_extents_R', 'ladder_extents_L', 'diving_platform' ]
    ]
    
    plt.figure( figsize=( 8 * plot_scale_factor, 6 * plot_scale_factor ) )
    reference_points.plot()

    pool_edge_plotter = PointPlotter(
        measurement_data = pool_edge_measurement_data,
        reference_points = reference_points,
    )
    pool_edge_plotter.plot_points()
    pool_edge_plotter.plot_curves()
    pool_edge_plotter.plot_labels( position_inside = True )
    plot_x_min, plot_y_min, plot_x_max, plot_y_max = pool_edge_plotter.plot_extents()

    if error_checking_enabled:
        pool_edge_plotter.plot_errors(
            error_check_measurement_data = error_check_measurement_data,
            error_threshold = error_threshold,
        )

    if obstruction_closeup:
        plot_x_min = 0.0
        plot_y_min = 0.0
        plot_x_max = -99999999.0
        plot_y_max = -99999999.0
        margin = 10
        
    for obstruction_measurement_data in obstruction_measurement_data_list:
        obstruction_plotter = PointPlotter(
            measurement_data = obstruction_measurement_data,
            reference_points = reference_points,
        )
        obstruction_plotter.plot_points(
            color = 'red',
        )
        obstruction_plotter.plot_lines( color = 'red' )
        obstruction_plotter.plot_labels( position_inside = False )

        x_min, y_min, x_max, y_max = obstruction_plotter.plot_extents()
        plot_x_min = min( plot_x_min, x_min )
        plot_y_min = min( plot_y_min, y_min )
        plot_x_max = max( plot_x_max, x_max )
        plot_y_max = max( plot_y_max, y_max )
        continue
    
    plt.axis('equal')  # Ensures equal scaling of x and y axes
    #plt.margins( margin )  # Remove automatic padding around data

    # Formatting
    plt.axhline( 0, color='black', linewidth = 0.5 )
    plt.axvline( 0, color='black', linewidth = 0.5 )
    plt.xlabel( "(inches)" )
    plt.ylabel( "(inches)" )

    # Define the grid lines and label positions
    major_ticks = np.arange( -500, 500, 50 )  # Labels at every 50 inches
    minor_ticks = np.arange( -500, 500, 10 )  # Grid lines at every 10 inches
    
    # Set grid and ticks
    plt.xticks(major_ticks)  # Major ticks every 50 inches (labeled)
    plt.yticks(major_ticks)  # Major ticks every 50 inches (labeled)
    
    plt.grid( True, which='both', linestyle='-', linewidth=0.5 )  # Enable grid
    plt.minorticks_on()  # Enable minor ticks for the 10-inch grid
    
    # Set minor ticks at every 10 inches without labels
    plt.gca().set_xticks( minor_ticks, minor = True )
    plt.gca().set_yticks( minor_ticks, minor = True )

    plt.xlim( plot_x_min - margin, plot_x_max + margin )  # Reduce extra space but leave 5 units padding
    plt.ylim( plot_y_min - margin, plot_y_max + margin )
    plt.tight_layout()  # Ensures best use of space
    
    plt.show()