Source code for suboptimumg.track.track_factory

from .gps import *
from .models import *
from .track import Track
from .utils import *




def from_corners(corner_input: CornerListInput):
    """
    Factory method to generate a Track class from a list of corners. Compatible with tracks saved in YAML.

    Parameters
    ----------
    corner_input : CornerListInput
        Corner list input containing corners and track parameters

    Returns
    -------
    Track
        Track instance created from corner list
    """
    # Convert corner length to step count. Optionally scale the length of a track.
    discretized_corners = scale_and_discretize_corner_lengths(
        corner_input.corners,
        corner_input.shorten * (0.1 / corner_input.distance_step),
    )

    x_m, y_m, arcs = corners_to_cartesian(
        discretized_corners,
        corner_input.distance_step,
        start_angle_deg=corner_input.ideal_rotation_angle,
    )

    if corner_input.clean_corners:
        discretized_corners = smooth_and_normalize_corner_radii(discretized_corners)

    dx, radius, cumulative_dist = unroll_corners_into_track(
        discretized_corners, corner_input.distance_step
    )

    return Track(
        dx,
        radius,
        cumulative_dist,
        x_m,
        y_m,
        corner_input.distance_step,
        False,
        original_corners=corner_input.corners,
        arcs=arcs,
    )





def from_coordinates(coord_input: CoordinateListInput):
    """
    Factory method to generate a Track from GPS coordinates (latitude/longitude).
    Creates a continuous representation with Menger curvature, then discretizes it.

    Parameters
    ----------
    coord_input: CoordinateListInput
        Contains GPS coordinates and track parameters

    Returns
    -------
    Track
        Track instance with continuous representation
    """
    spline_data, tck, cumulative_dist = gps_interpolate(coord_input, smooth=0.000000082)

    x_m, y_m = gps_to_cartesian(spline_data, origin_offset=True)

    # Calculate radii and dx
    dx = np.full(cumulative_dist.shape, coord_input.distance_step)

    radii = np.full(cumulative_dist.shape, 0.0)
    for idx in range(len(cumulative_dist)):
        _, radius = calculate_menger_curvature(
            x_m,
            y_m,
            cumulative_dist,
            cumulative_dist[idx],
            coord_input.sample_dist,
        )
        radii[idx] = radius

    return Track(
        dx,
        radii,
        cumulative_dist,
        x_m,
        y_m,
        coord_input.distance_step,
        True,
        sample_dist=coord_input.sample_dist,
        tck=tck,
    )





def from_data(data: TrackData) -> Track:
    """
    Factory method to create a Track from a TrackData model.

    Parameters
    ----------
    data : ContinuousTrackData | DiscreteTrackData
        A TrackData instance containing all track fields including pre-computed seed indices

    Returns
    -------
    Track
        A new Track instance with all fields populated from the data model
    """
    # Create a new Track instance without calling __init__
    instance = Track.__new__(Track)

    # Set common fields
    instance.dx = data.dx
    instance.radius = data.radius
    instance.cumulative_dist = data.cumulative_dist
    instance.x_m = data.x_m
    instance.y_m = data.y_m
    instance.distance_step = data.distance_step
    instance.seed_idx = data.seed_idx

    # Set type-specific fields
    match data:
        case ContinuousTrackData():
            instance.continuous = True
            instance.sample_dist = data.sample_dist
            instance.tck = data.tck
        case DiscreteTrackData():
            instance.continuous = False
            instance.original_corners = data.original_corners
            instance.arcs = data.arcs

    return instance