opencpn_table – OpenCPN Table Application

The opencpn_table application is used to do extract a useful CSV formatted file from the OpenCPN planning display.

The display is a CSV file with a great deal of supplemental formatting. This application strips away the formatting so the data can be more easily loaded into a spreadsheet.

Here’s the structure of this application

This module includes several groups of components.

• The Input Parsing group is the functions and classes that acquire input from the GPX or CSV file.

• The Output Writing group is the functions to write the CSV result.

• Finally, the Command-Line Interface components are used to build a proper command-line application.

Input Parsing

The data is a CSV file with a fixed set of columns.

"Leg", "To waypoint", "Distance", "Bearing",
"Latitude", "Longitude", "ETE", "ETA",
"Speed", "Next tide event", "Description", "Course"

Core objects

A Leg is the space between waypoints. Rather than repeat each endpoint, only the ending point is shown and the starting point is implied by the previous leg’s ending point.

class navtools.opencpn_table.Leg(waypoint: navtools.navigation.Waypoint, leg: int, ETE: Optional[navtools.opencpn_table.Duration], ETA: Optional[datetime.datetime], ETA_summary: Optional[str], speed: float, tide: Optional[str], distance: Optional[float], bearing: Optional[float], course: Optional[float] = None)

Map attribute values between OpenCPN CSV, something Pythonic, and a more generic CSV with less fancy formatting.

A Leg is the space between two Waypoints. One Waypoint is assumed (it’s the “current” waypoint.) The other is stated explicitly as the end-point for this leg.

This is a composite of a Waypoint plus some derived values.

Todo

Unify with planning.SchedulePoint.

waypoint: navtools.navigation.Waypoint

leg: int

ETE: Optional[navtools.opencpn_table.Duration]

ETA: Optional[datetime.datetime]

ETA_summary: Optional[str]

speed: float

tide: Optional[str]

distance: Optional[float]

bearing: Optional[float]

course: Optional[float] = None

attr_names: ClassVar[tuple] = (('Leg', <function Leg.<lambda>>), ('To waypoint', <function Leg.<lambda>>), ('Distance', <function Leg.<lambda>>), ('Bearing', <function Leg.<lambda>>), ('Latitude', <function Leg.<lambda>>), ('Longitude', <function Leg.<lambda>>), ('ETE', <function Leg.<lambda>>), ('ETA', <function Leg.<lambda>>), ('Speed', <function Leg.<lambda>>), ('Next tide event', <function Leg.<lambda>>), ('Description', <function Leg.<lambda>>), ('Course', <function Leg.<lambda>>))

classmethod fromdict(details: dict) → navtools.opencpn_table.Leg

Transform a line of CSV data from the input document into a Leg.

asdict() → dict

Emits a Leg as a dictionary. Uses the attr_names mapping to original CSV attribute names.

A Route is an ordered collection of Leg instances with some overall summary data.

class navtools.opencpn_table.Route(summary: dict, details: Iterable[dict])

The overall Route. A number of pre-computed attributes are available, like the estimated duration and distance. The values of Speed and Departure are inputs, actually. The Name, Depart From, and Destination attributes are the most valuable.

classmethod load(path: pathlib.Path) → navtools.opencpn_table.Route

Loads a Route from a given CSV file. This breaks the CSV into three parts:

• The heading rows. These one or two columns.

• A blank row.

• The leg rows, which have a large number of columns.

Parameters

path – the Path to a CSV file.

Returns

Route

A Duration is a span of time, not an absolute point in time. This is essentially similar to datetime.timedelta.

class navtools.opencpn_table.Duration(d: int = 0, h: int = 0, m: int = 0, s: int = 0)

A duration in days, hours, minutes, and seconds.

We map between hours or minutes as float and (d, h, m, s) duration values.

To an extent, this is similar to datetime.timedelta. It supports simple math to add and subtract durations.

We need to also support the following for full rate-time-distance computations:

• duration * float = float (rate*time = distance)

• float * duration = float

• float / duration = float (distance / time = rate)

• duration / float = duration

There’s no trivial way to handle distance / rate = time. This must be done explicitly as Duration.fromfloat(minutes=60*distance/rate)

Dataclass provides hash, equality, and ordering for us.

d: int = 0

h: int = 0

m: int = 0

s: int = 0

classmethod parse(text: str) → navtools.opencpn_table.Duration

Parses a duration field into days, hours, minutes, and seconds.

Parameters

text – a string with digits and unit labels of “d”, “H”, “M”, or “S”.

Returns

Duration

property days: float

Returns

a single float in days

property hours: float

Returns

a single float in hours

property minutes: float

Returns

a single float in minutes

property seconds: int

Returns

a single int in seconds

classmethod fromfloat(*, days: Optional[float] = 0, hours: Optional[float] = 0, minutes: Optional[float] = 0, seconds: Optional[float] = 0) → navtools.opencpn_table.Duration

Normalize to seconds.

classmethod normalized(seconds: int) → navtools.opencpn_table.Duration

Output Writing

We’re creating a CSV output file with de-formatted inputs. We maintain the column titles for simplistic compatibility with the source file.

navtools.opencpn_table.to_html(route: navtools.opencpn_table.Route) → None

Prints an HTML version of the supplied OpenCPN data.

Parameters

route – a Route object.

navtools.opencpn_table.to_csv(route: navtools.opencpn_table.Route) → None

Converts OpenCPN to a more spreadsheet friendly format. Writes to stdout.

Parameters

route – a Route object.

Command-Line Interface

We generally use it like this:

python -m navtools.opencpn_table 'planned_route.csv'

navtools.opencpn_table.main(argv: list) → None

Reads an OpenCPN route plan, and reformats it so it’s easier to load into a spreadsheet.