![\"Indiana](\"https://j.gifs.com/vO2k6P.gif\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Great Circle Arcs and Path"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "Imagine a plane, flying from Cario to Hong Kong. To a passenger, the plane appears to travel a straight path, but the plane actually curves around the surface, held down by the gravity of the planet\n",
+ "\n",
+ "Great circles are circles that circumnavigate the globe\n",
+ "\n",
+ "1. Determine the Length/Distance of a Great Circle Arc\n",
+ "1. Determine the Bearing of a Great Circle Arc\n",
+ "1. Generating a Great Circle Arc with Intermediates Points\n",
+ "1. Determine the Midpoint of a Great Circle Arc (TODO)\n",
+ "1. Compare Great Circle Arc to Rhumb Line (TODO)\n",
+ "1. Generate a Great Circle Path"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prerequisites\n",
+ "\n",
+ "| Concepts | Importance | Notes |\n",
+ "| --- | --- | --- |\n",
+ "| [Numpy](https://foundations.projectpythia.org/core/numpy.html) | Necessary | |\n",
+ "| [Pandas](https://foundations.projectpythia.org/core/numpy.html) | Necessary | |\n",
+ "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy.html) | Helpful | Will be used for plotting |\n",
+ "| [Matplotlib](https://foundations.projectpythia.org/core/matplotlib.html) | Helpful | Will be used for plotting |\n",
+ "\n",
+ "- **Time to learn**: 40 minutes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Imports"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd # reading in data for location information from text file\n",
+ "import numpy as np # working with arrays, vectors, cross/dot products, and radians\n",
+ "\n",
+ "from pyproj import Geod # working with the Earth as an ellipsod (WGS-84)\n",
+ "import geopy.distance # working wtih the Earth as an ellipsod"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "![\"24](\"https://assets.weforum.org/editor/u0p_rm0X1NiSU4iew5pqT_c-ruHapJWPlXoLkS88ncQ.gif\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Great Circles and a Point"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "A plane traveling across the country suddenly discovers it is low on fuel! It can no longer make it to the distant planned airport, instead it has to find the closest airport to its current position that it can make it with its remaining fuel\n",
+ "\n",
+ "1. Determine the distance of a point to a great circle arc\n",
+ "1. Determine the distance of a point to a great circle path\n",
+ "1. Determine if a point lies on a great circle arc and path (with/without tolerances)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prerequisites\n",
+ "\n",
+ "| Concepts | Importance | Notes |\n",
+ "| --- | --- | --- |\n",
+ "| [Numpy](https://foundations.projectpythia.org/core/numpy.html) | Necessary | |\n",
+ "| [Pandas](https://foundations.projectpythia.org/core/numpy.html) | Necessary | |\n",
+ "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy.html) | Helpful | Will be used for plotting |\n",
+ "| [Matplotlib](https://foundations.projectpythia.org/core/matplotlib.html) | Helpful | Will be used for plotting |\n",
+ "\n",
+ "\n",
+ "- **Time to learn**: estimate in minutes. For a rough idea, use 5 mins per subsection, 10 if longer; add these up for a total. Safer to round up and overestimate."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "![\"Project](\"images/ProjectPythia_Logo_Final-01-Blue.svg\"){kind=logo}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Great Circles and Parallels"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "If you have an introductory paragraph, lead with it here! Keep it short and tied to your material, then be sure to continue into the required list of topics below,\n",
+ "\n",
+ "1. This is a numbered list of the specific topics\n",
+ "1. These should map approximately to your main sections of content\n",
+ "1. Or each second-level, `##`, header in your notebook\n",
+ "1. Keep the size and scope of your notebook in check\n",
+ "1. And be sure to let the reader know up front the important concepts they'll be leaving with"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prerequisites\n",
+ "\n",
+ "| Concepts | Importance | Notes |\n",
+ "| --- | --- | --- |\n",
+ "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy.html) | Necessary | |\n",
+ "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf.html) | Helpful | Familiarity with metadata structure |\n",
+ "| Project management | Helpful | |\n",
+ "\n",
+ "- **Time to learn**: estimate in minutes. For a rough idea, use 5 mins per subsection, 10 if longer; add these up for a total. Safer to round up and overestimate."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Summary\n",
+ "Determine the coordinates when a great circle path crosses a specific parallel as well as the maximumn and minimum latitude coordiantes\n",
+ "\n",
+ "### What's next?\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Resources and references"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.8"
+ },
+ "nbdime-conflicts": {
+ "local_diff": [
+ {
+ "diff": [
+ {
+ "diff": [
+ {
+ "key": 0,
+ "op": "addrange",
+ "valuelist": [
+ "Python 3"
+ ]
+ },
+ {
+ "key": 0,
+ "length": 1,
+ "op": "removerange"
+ }
+ ],
+ "key": "display_name",
+ "op": "patch"
+ }
+ ],
+ "key": "kernelspec",
+ "op": "patch"
+ }
+ ],
+ "remote_diff": [
+ {
+ "diff": [
+ {
+ "diff": [
+ {
+ "key": 0,
+ "op": "addrange",
+ "valuelist": [
+ "Python3"
+ ]
+ },
+ {
+ "key": 0,
+ "length": 1,
+ "op": "removerange"
+ }
+ ],
+ "key": "display_name",
+ "op": "patch"
+ }
+ ],
+ "key": "kernelspec",
+ "op": "patch"
+ }
+ ]
+ },
+ "toc-autonumbering": false
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/_preview/1/notebooks/foundations/coordinates.html b/_preview/1/notebooks/foundations/coordinates.html
index 6530472..3cd202f 100644
--- a/_preview/1/notebooks/foundations/coordinates.html
+++ b/_preview/1/notebooks/foundations/coordinates.html
@@ -408,17 +408,13 @@ 
+
+
+
+
Great Circle Arcs and Path
++
Overview
+Imagine a plane, flying from Cario to Hong Kong. To a passenger, the plane appears to travel a straight path, but the plane actually curves around the surface, held down by the gravity of the planet
+Great circles are circles that circumnavigate the globe
+-
+
Determine the Length/Distance of a Great Circle Arc
+Determine the Bearing of a Great Circle Arc
+Generating a Great Circle Arc with Intermediates Points
+Determine the Midpoint of a Great Circle Arc (TODO)
+Compare Great Circle Arc to Rhumb Line (TODO)
+Generate a Great Circle Path
+
Prerequisites
+Concepts |
+Importance |
+Notes |
+
|---|---|---|
| + | Necessary |
++ |
| + | Necessary |
++ |
| + | Helpful |
+Will be used for plotting |
+
| + | Helpful |
+Will be used for plotting |
+
-
+
Time to learn: 40 minutes
+
+
Imports
+
+
+
+
+
+
+import pandas as pd # reading in data for location information from text file
+import numpy as np # working with arrays, vectors, cross/dot products, and radians
+
+from pyproj import Geod # working with the Earth as an ellipsod (WGS-84)
+import geopy.distance # working wtih the Earth as an ellipsod
+
+
+
+
+
+
+# Get all Coordinates for Locations
+location_df = pd.read_csv("../location_full_coords.txt")
+location_df = location_df.rename(columns=lambda x: x.strip()) # strip excess white space from column names and values
+location_df.head()
+
+
+
+
+
+
+
+
| + | name | +latitude | +longitude | +cart_x | +cart_y | +cart_z | +rho | +theta | +phi | +polar_x | +polar_y | +polar_z | +
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | +arecibo | +18.3441 | +-66.7527 | +2.389526e+06 | +-5.562495e+06 | +2.007347e+06 | +6378137.0 | +-1.165054 | +1.250631 | +-0.872119 | +0.374643 | +0.314723 | +
| 1 | +boulder | +40.0150 | +-105.2705 | +-1.286558e+06 | +-4.712394e+06 | +4.101066e+06 | +6378137.0 | +1.304276 | +0.872403 | +-0.738835 | +-0.201714 | +0.642988 | +
| 2 | +boston | +42.3601 | +-71.0589 | +1.529809e+06 | +-4.457769e+06 | +4.297512e+06 | +6378137.0 | +-1.240212 | +0.831473 | +-0.698914 | +0.239852 | +0.673788 | +
| 3 | +red woods | +41.4017 | +-124.0417 | +-2.678169e+06 | +-3.964322e+06 | +4.218080e+06 | +6378137.0 | +0.976657 | +0.848200 | +-0.621549 | +-0.419898 | +0.661334 | +
| 4 | +houston | +29.5518 | +-95.0982 | +-4.930480e+05 | +-5.526456e+06 | +3.145762e+06 | +6378137.0 | +1.481816 | +1.055020 | +-0.866469 | +-0.077303 | +0.493210 | +
+
+
+
+
+
+location_df.index = location_df["name"]
+Distance Between Points on a Great Circle Arc
+Determine Distance Mathematically
+TODO
+Determine Distance Points via Python Package pyproj
+pyproj accounts for different ellipsoids like WGS-84
+
+
+
+
+
+geodesic = Geod(ellps="WGS84")
+
+
+
+
+
+
+location_df.loc[["boulder", "boston"]]
+
+
+
+
+
+
+
+
| + | name | +latitude | +longitude | +cart_x | +cart_y | +cart_z | +rho | +theta | +phi | +polar_x | +polar_y | +polar_z | +
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| name | ++ | + | + | + | + | + | + | + | + | + | + | + |
| boulder | +boulder | +40.0150 | +-105.2705 | +-1.286558e+06 | +-4.712394e+06 | +4.101066e+06 | +6378137.0 | +1.304276 | +0.872403 | +-0.738835 | +-0.201714 | +0.642988 | +
| boston | +boston | +42.3601 | +-71.0589 | +1.529809e+06 | +-4.457769e+06 | +4.297512e+06 | +6378137.0 | +-1.240212 | +0.831473 | +-0.698914 | +0.239852 | +0.673788 | +
+
+
+
+
+
+_, _, distance_meter = geodesic.inv(location_df.loc[["boulder"]]["longitude"].iloc[0],
+ location_df.loc[["boulder"]]["latitude"].iloc[0],
+ location_df.loc[["boston"]]["longitude"].iloc[0],
+ location_df.loc[["boston"]]["latitude"].iloc[0])
+
+print(f"Distance between coordinates = {distance_meter/1000} km")
+
+
+
+
+Distance between coordinates = 2862.5974799145215 km
+Compared to the distance from the associated airports in Denver and Boston (DIA to Logan) which has a distance of 2823 km
+Determine the Bearing of a Great Circle Arc
+Determine the Bearing Mathematically
+TODO
+Determine the Bearing via Python Package pyproj
+pyproj accounts for different ellipsoids like WGS-84
+
+
+
+
+
+fwd_bearing, rvs_bearing, _ = geodesic.inv(location_df.loc[["boulder"]]["longitude"].iloc[0],
+ location_df.loc[["boulder"]]["latitude"].iloc[0],
+ location_df.loc[["boston"]]["longitude"].iloc[0],
+ location_df.loc[["boston"]]["latitude"].iloc[0])
+
+print(f"foward bearing between coordinates = {fwd_bearing} Degrees")
+print(f"reverse bearing between coordinates = {rvs_bearing} Degrees")
+
+
+
+
+foward bearing between coordinates = 73.51048829569022 Degrees
+reverse bearing between coordinates = -83.57035585674933 Degrees
+Generating a Great Circle Arc with Intermediates Points
+Determine Intermediate Points Mathemetically
+TODO
+Determine Intermediate Points via Python Package pyproj and geopy
+-
+
Interpolate with N total equally spaced number of points
+Interpolate every N meters
+
+
+
+
+
+
+def interpolate_points_along_gc(lat_start,
+ lon_start,
+ lat_end,
+ lon_end,
+ distance_between_points_meter):
+ lat_lon_points = [(lat_start, lon_start)]
+
+ # move to next point when distance between points is less than the equal distance
+ move_to_next_point = True
+ while(move_to_next_point):
+ forward_bearing, _, distance_meters = geodesic.inv(lon_start,
+ lat_start,
+ lon_end,
+ lat_end)
+ if distance_meters < distance_between_points_meter:
+ # ends before overshooting
+ move_to_next_point = False
+ else:
+ start_point = geopy.Point(lat_start, lon_start)
+ distance_to_move = geopy.distance.distance(
+ kilometers=distance_between_points_meter /
+ 1000) # distance to move towards the next point
+ final_position = distance_to_move.destination(
+ start_point, bearing=forward_bearing)
+ lat_lon_points.append((final_position.latitude, final_position.longitude))
+ # new starting position is newly found end position
+ lon_start, lat_start = final_position.longitude, final_position.latitude
+ lat_lon_points.append((lat_end, lon_end))
+ return lat_lon_points
+Plot Arcs as Points on a World Map
+
+
+
+
+
+
+import matplotlib.pyplot as plt
+from cartopy import crs as ccrs, feature as cfeature
+
+def plot_coordinate(lst_of_coords=None, title=None):
+ # Set up world map plot on the United States
+ fig = plt.subplots(figsize=(15, 10))
+ projection_map = ccrs.PlateCarree()
+ ax = plt.axes(projection=projection_map)
+ lon_west, lon_east, lat_south, lat_north = -130, -60, 20, 60
+ ax.set_extent([lon_west, lon_east, lat_south, lat_north], crs=projection_map)
+ ax.coastlines(color="black")
+ ax.add_feature(cfeature.STATES, edgecolor="black")
+
+ # Plot Latitude/Longitude Location
+ longitudes = [x[1] for x in lst_of_coords] # longitude
+ latitudes = [x[0] for x in lst_of_coords] # latitude
+ plt.plot(longitudes, latitudes)
+ plt.scatter(longitudes, latitudes)
+
+ # Setup Axis Limits and Title/Labels
+ plt.title(title)
+ plt.show()
+Interpolate with N Total Equally Spaced Points
+
+
+
+
+
+
+n_total_points = 10 # total points (n points)
+distance_between_points_meter = distance_meter / (n_total_points + 1)
+print(f"Each point will be seperated by {distance_between_points_meter} meters ({distance_between_points_meter/1000} km)")
+
+
+
+
+Each point will be seperated by 260236.13453768377 meters (260.23613453768377 km)
+
+
+
+
+
+
+lat_start, lon_start = location_df.loc[["boulder"]]["latitude"].iloc[0], location_df.loc[["boulder"]]["longitude"].iloc[0]
+lat_end, lon_end = location_df.loc[["boston"]]["latitude"].iloc[0], location_df.loc[["boston"]]["longitude"].iloc[0]
+
+every_n_pts = interpolate_points_along_gc(lat_start,
+ lon_start,
+ lat_end,
+ lon_end,
+ distance_between_points_meter)
+print(f"{len(every_n_pts)} Total Points")
+every_n_pts
+
+
+
+
+
+
+12 Total Points
+[(np.float64(40.015), np.float64(-105.2705)),
+ (40.64283438472448, -102.32002071588883),
+ (41.19386139956729, -99.31719425393653),
+ (41.665293789240074, -96.2672998277903),
+ (42.05464865958041, -93.17653047007545),
+ (42.35980367525435, -90.05192021556942),
+ (42.579048241302566, -86.9012334462751),
+ (42.71112689737456, -83.73281874084786),
+ (42.75527239726804, -80.5554326250441),
+ (42.711226442193585, -77.37804142647055),
+ (42.579246749547636, -74.20961159223961),
+ (np.float64(42.3601), np.float64(-71.0589))]
+
+
+
+
+
+
+plot_coordinate(lst_of_coords=every_n_pts,
+ title=f"Interpolate {n_total_points} Points")
+
+
+
+
+Interpolate every N meters
+
+
+
+
+
+
+distance_between_points_meter = 112000
+print(f"Each point will be seperated by {distance_between_points_meter} meters ({distance_between_points_meter/1000} km)")
+
+
+
+
+Each point will be seperated by 112000 meters (112.0 km)
+
+
+
+
+
+
+lat_start, lon_start = location_df.loc[["boulder"]]["latitude"].iloc[0], location_df.loc[["boulder"]]["longitude"].iloc[0]
+lat_end, lon_end = location_df.loc[["boston"]]["latitude"].iloc[0], location_df.loc[["boston"]]["longitude"].iloc[0]
+
+every_n_pts = interpolate_points_along_gc(lat_start,
+ lon_start,
+ lat_end,
+ lon_end,
+ distance_between_points_meter)
+print(f"{len(every_n_pts)} Total Points")
+every_n_pts
+
+
+
+
+
+
+27 Total Points
+[(np.float64(40.015), np.float64(-105.2705)),
+ (40.29443152420481, -104.00739372929635),
+ (40.55994883031889, -102.73410083358552),
+ (40.811312209497714, -101.45097760323463),
+ (41.04829010633232, -100.15841313140038),
+ (41.27065999040772, -98.8568290209118),
+ (41.47820922569627, -97.54667886388195),
+ (41.67073593071231, -96.22844748540258),
+ (41.848049822017195, -94.90264994540797),
+ (42.00997303342117, -93.56983029584387),
+ (42.156340903095064, -92.23056009359964),
+ (42.287002720790326, -90.88543667319323),
+ (42.40182242747838, -89.53508118686946),
+ (42.50067925996674, -88.1801364234981),
+ (42.583468333429785, -86.82126442135142),
+ (42.65010115530707, -85.45914389340653),
+ (42.700506064664665, -84.09446748716023),
+ (42.73462859187762, -82.72793890397021),
+ (42.75243173435998, -81.36026990555973),
+ (42.75389614502746, -79.99217723746453),
+ (42.73902023120852, -78.62437950079696),
+ (42.707820162798164, -77.25759400470386),
+ (42.66032978955507, -75.89253363227026),
+ (42.596600468550456, -74.52990375235937),
+ (42.51670080386281, -73.1703992089883),
+ (42.42071630165334, -71.81470141834599),
+ (np.float64(42.3601), np.float64(-71.0589))]
+
+
+
+
+
+
+plot_coordinate(lst_of_coords=every_n_pts,
+ title=f"Interpolate every {distance_between_points_meter/1000} km")
+
+
+
+
+Generate a Great Circle Path
+Get points on the Great Cricle defined by two points
+
+
+
+
+
+
+# Generate Latitude Coordinates based on Longitude Coordinates
+def generate_latitude_along_gc(start_point=None, end_point=None, longitude_lst=None):
+ lon1 = np.deg2rad(location_df.loc[[start_point]]["longitude"].iloc[0])
+ lat1 = np.deg2rad(location_df.loc[[start_point]]["latitude"].iloc[0])
+ lon2 = np.deg2rad(location_df.loc[[end_point]]["longitude"].iloc[0])
+ lat2 = np.deg2rad(location_df.loc[[end_point]]["latitude"].iloc[0])
+
+ # Verify not meridian (longitude passes through the poles)
+ if np.sin(lon1 - lon2) == 0:
+ print("Invalid inputs: start/end points are meridians")
+ print("TODO: Fix for plotting meridians")
+ # TODO: fix for plotting meridians at 0 longitude through all latitudes
+ meridians = np.arange(-90, 90, 180/len(longitude_lst)) # split in n number
+ return meridians
+
+
+ # verify not anitpodal (diametrically opposite, points)
+ if lat1 + lat2 == 0 and abs(lon1-lon2) == np.pi:
+ print("Invalid inputs: start/end points are antipodal")
+ return []
+
+ # note: can be expanded to handle input of np arrays by filter out antipodal/merdiain points
+
+ lon_lst = np.deg2rad(longitude_lst)
+
+ gc_lat = []
+ # Intermediate points on a great circle: https://edwilliams.org/avform147.htm"
+ for gc_lon in lon_lst:
+ num = np.sin(lat1)*np.cos(lat2)*np.sin(gc_lon-lon2)-np.sin(lat2)*np.cos(lat1)*np.sin(gc_lon-lon1)
+ den = np.cos(lat1)*np.cos(lat2)*np.sin(lon1-lon2)
+ new_lat = np.arctan(num/den)
+ gc_lat.append(np.rad2deg(new_lat))
+ return gc_lat
+
+
+
+
+
+
+def arc_points(start_lat=None,
+ start_lon=None,
+ end_lat=None,
+ end_lon=None,
+ n_total_points=10):
+ _, _, distance_meter = geodesic.inv(start_lon,
+ start_lat,
+ end_lon,
+ end_lat)
+
+ distance_between_points_meter = distance_meter / (n_total_points + 1)
+
+
+ points_along_arc = interpolate_points_along_gc(start_lat,
+ start_lon,
+ end_lat,
+ end_lon,
+ distance_between_points_meter)
+ return points_along_arc
+
+
+
+
+
+
+# generate n total number of longitude points along the great circle
+# https://github.com/rspatial/geosphere/blob/master/R/greatCircle.R#L18C3-L18C7
+def generate_longitude_along_gc(n_pts=None):
+ gc_lon = []
+ for lon in range(1, n_pts+1):
+ new_lon = (lon * (360/n_pts) - 180)
+ gc_lon.append(new_lon)
+ return gc_lon
+
+
+
+
+
+
+def plot_coordinate(lat_lst=None, lon_lst=None,
+ start_point=None, end_point=None,
+ title=None):
+ # Set up world map plot
+ fig = plt.subplots(figsize=(15, 10))
+ projection_map = ccrs.PlateCarree()
+ ax = plt.axes(projection=projection_map)
+ lon_west, lon_east, lat_south, lat_north = -180, 180, -90, 90
+ ax.set_extent([lon_west, lon_east, lat_south, lat_north], crs=projection_map)
+ ax.coastlines(color="black")
+ ax.add_feature(cfeature.BORDERS, edgecolor='grey')
+ ax.add_feature(cfeature.STATES, edgecolor="grey")
+
+
+ # Plot Latitude/Longitude Location of great circle path
+ plt.plot(lon_lst, lat_lst)
+ plt.scatter(lon_lst, lat_lst)
+
+ # Overly great circle with arc rom start/end point
+ start_end_lat_lon = arc_points(location_df.loc[[start_point]]["latitude"].iloc[0],
+ location_df.loc[[start_point]]["longitude"].iloc[0],
+ location_df.loc[[end_point]]["latitude"].iloc[0],
+ location_df.loc[[end_point]]["longitude"].iloc[0],
+ n_total_points=20)
+ longitudes = [x[1] for x in start_end_lat_lon] # longitude
+ latitudes = [x[0] for x in start_end_lat_lon] # latitude
+ plt.plot(longitudes, latitudes, c="red")
+ plt.scatter(longitudes, latitudes, c="red")
+
+ # Setup Axis Limits and Title/Labels
+ plt.title(title)
+ plt.show()
+
+
+
+
+
+
+n = 360
+lon_pts = generate_longitude_along_gc(n)
+
+
+
+
+
+
+start_pt = "boulder"
+end_pt = "boston"
+lat_pts = generate_latitude_along_gc(start_pt, end_pt, lon_pts)
+plot_coordinate(lat_pts, lon_pts, start_pt, end_pt,
+ f"Plot Great Circle, made from the arc {start_pt.title()} to {end_pt.title()}, every {n} points along the longitude")
+
+
+
+
+
+
+
+
+
+
+start_pt = "arecibo"
+end_pt = "greenwich"
+lat_pts = generate_latitude_along_gc(start_pt, end_pt, lon_pts)
+plot_coordinate(lat_pts, lon_pts, start_pt, end_pt,
+ f"Plot Great Circle, made from the arc {start_pt.title()} to {end_pt.title()}, every {n} points along the longitude")
+
+
+
+
+
+
+
+
+
+
+start_pt = "zambezi"
+end_pt = "svalbard"
+lat_pts = generate_latitude_along_gc(start_pt, end_pt, lon_pts)
+plot_coordinate(lat_pts, lon_pts, start_pt, end_pt,
+ f"Plot Great Circle, made from the arc {start_pt.title()} to {end_pt.title()}, every {n} points along the longitude")
+
+
+
+
++
Summary
+Calculating and mapping the midpoint and intermediate points along the great circle arc and closed circle path
+What’s next?
+With a great circle arc defined, determine if a third point is along the arc or at what distance it sits from the great circle arc and path
+
+ 
+
+
