This major release is packed with new features, especially the new
CZML exporting capabilities and miscellaneous additions and important fixes
on the algorithmic side. It also sets a new high in terms of contributors,
which makes us extremely proud and thankful!

Export Orbit objects to CZML: There is new experimental functionality to
export Orbit to CZML, the JSON format used
by the Cesium visualization system. This complements poliastro capabilities
and allows users to produce gorgeous visualizations, like the one below.
We also kickstarted a new project called czml3 a Python 3 interface to CZML,
to support all these new capabilities, and created a base Cesium application
so you can quickly start experimenting. Let us know your thoughts!

2D plots are static by default: Getting Plotly properly installed is
a bit more difficult than just a pipinstall nowadays, and
it turns out we alienated some of our non-Jupyter users by pushing it too soon
(especially those of you that use Spyder). We have tried hard in this release
to make the default plotting work everywhere by sticking again to matplotlib,
while allowing more proficient users to install all the necessary components
to have interactive visualizations going. If you still find issues, tell us!

New Lambert maneuver: After a long time, Lambert transfers are finally
a Maneuver, which means it shares the same API
as Hohmann and bielliptic transfers among others, making it easier to use.

Lots of new propagators: And when we say _lots_, we mean it! Lots of
authors claim their propagator is “universal”, but to our knowledge this is
almost always a slight overstatement. To enrich poliastro with new propagation
methods and allow users to test them with all kinds of crazy orbits
(especially quasy-parabolic ones) we implemented a ton of new propagators,
all sharing the same API. You have more information in this article about
the new propagators in our blog.

Python 3.6+ only: Python 3.5 has done a great service and will still be
supported by Astropy a few more months, but we already wanted to move on
and embrace fixed-order dictionaries, f-strings, and decimal separators,
among others. This release of poliastro requires Python 3.6 or higher to work.
We are also getting ready for Python 3.8!

Arrival velocity contour lines in porkchop plots: Now porkchop plots are a bit richer
and display arrival velocity as well.

Experimental Geocentric Solar Ecliptic frame: We introduced an experimental
implementation of a Geocentric Solar Ecliptic frame, which is used for studies of
Near Earth Objects. Please help us validating it!

Plot orbit trails: Apart from plotting orbits as solid or dashed lines, now
it’s easier to visualize the actual direction of the orbit using trail=True.

New :code:`change_attractor` method: Now it’s easier to translate the origin
of an orbit (withing the patched conics framework) to study it from a different perspective
using the change_attractor() method.

New :code:`SpheroidLocation`: We also added a experimental
poliastro.spheroid_location.SpheroidLocation, which tries to generalize
astropy.coordinates.EarthLocation to other bodies.

New orbital properties: Angular momentum, mean anomaly, time of perifocal passage
of Orbit are now very easy to compute.

This major release brings lots of new features, several breaking changes
that improve the overall consistency of the library, and a stronger bet
on Plotly as the default plotting backend, as well as the usual bug fixes.
This has been the biggest release in terms of contributors so far and
we feel we are reaching a tipping point, which makes us extremely proud
and also busier!

New defaults for plotting: We are now switching to Plotly for the default
plotting backend as it has better interactive capabilities in the notebook,
while keeping the matplotlib backend for publication-quality, 2D static plots.
There might be some rough edges in the installation or in trying to keep the
aspect ratio still, so we ask for user feedback.

Reorganization of propagation capabilities: We made some changes to the propagation
APIs to be more coherent and flexible and simpler to understand for new contributors.
We removed some features from sample() to
keep it simpler while moving some of them to
poliastro.twobody.propagation.propagate(), and we splitted
propagate() by adding
propagate_to_anomaly(). At the cost of
some breakage, we think this is a positive change that will make the library
more maintainable in the future and reduce the number of bugs.

Better integration with reference frames: We took one step further in our
endeavor to integrate better with Astropy reference frames by adding a
from_coords() method that accepts
any frame, be it inertial or not.

Refactor of Orbit objects: The Orbit
was designed a long time ago and some design choices prevented all its
orbital properties to appear in the documentation, while also making people
think that they had to use an internal property. After a simple refactor
this is no longer the case, and the code is still fast while being
much simpler to understand. Did you know that you can compute the
semilatus rectum, the modified equinoctial elements, the eccentricity vector
or the mean motion of an Orbit?
Now there are no excuses!

New orbit creation methods: We can create an
Orbit directly from JPL HORIZONS data using
from_horizons(), from Astropy
SkyCoord and BaseCoordinateFrame objects using
from_coords(), and Geostationary orbits
around an attractor using geostationary().
We plan to keep adding more in the coming releases.

New propagation methods: We now have more specific methods for certain
tasks, like propagate_to_anomaly() to
propagate an Orbit to a certain anomaly,
and we can specify the anomaly limits when using
sample().

New simple plotting method: We added a
plot() to quickly plot an
Orbit without additional imports, in 2D or 3D.

Dark theme for Plotly plots: It is now possible to create Plotly plots
with a dark background, perfect for recreating our Solar System!

Porkchop plots: By popular demand, we can now produce gorgeousPorkchop plots to analyze launch opportunities between origin and
destination bodies by using poliastro.plotting.porkchop.porkchop().
We plan to expand its capabilities by being able to target any body of
the Solar System. Stay tuned!

Lagrange points: The new experimental module poliastro.threebody.restricted
contains functions to compute the Lagrange points in the circular restricted three body
problem (CR3BP). It has been validated only approximately, so use it at your own risk.

Reference frames: We addded experimental support for reference frames in poliastro objects.
So far, the Orbit objects were in some assumed reference
frame that could not be controlled, leading to some confusion by people that wanted some
specific coordinates. Now, the reference frame is made out explicit, and there is also
the possibility to make a limited set of transformations. This framework will be further
developed in the next release and transformations to arbitrary frames will be allowed.
Check out the poliastro.frames module for more information.

This major release brings important changes from the code perspective
(including a major change in the structure of the library),
several performance improvements
and a new infrastructure for running timing benchmarks,
as well as some new features and bug fixes.

Major change in the structure of poliastro codebase: We separated the high level,
units safe functions from the low level, fast ones, with the subsequent improvement
in code quality. With this change we effectively communicate where “core” algorithms
should go, make easier for future contributors to add numerical functions, and
improved the overall quality of the library.

Upgrade to new SciPy ODE solvers: We wrote our own version of Dormand-Prince 8(5,3)
based on the new IVP framework in SciPy 1.0 to take advantage of event detection,
dense output and other fancy features. In particular,
the sample() method now uses dense output when available,
therefore removing the need to propagate the orbit repeatedly.

New infrastructure for benchmarks: We started publishing timing benchmarks results
using Airspeed Velocity, a Python framework for writing, running, studying and
publishing benchmarks. Besides, we bought a dedicated machine to run them with
as much precision as we can.
Please check them out
and consider adding new benchmarks as well!

Several performance improvements: Now that we are tracking performance, we dedicated
some time during this release to fix some performance regressions that appeared in
propagation, improving the behavior near parabolic orbits, and accelerating (even more!)
the Izzo algorithm for the Lambert problem as well as some poliastro utilities.

New Continuous Integration infrastructure: We started to use CircleCI for the
Linux tests, the coverage measurements and the documentation builds. This service
has faster machines and better support for workflows, which significantly reduced
the build times and completely removed the timeouts that were affecting us in
Travis CI.

Plotly backends now stable: We fixed some outstanding issues with the 2D Plotly backend
so now it’s no longer experimental. We also started refactoring some parts of the plotting module
and prepared the ground for the new interactive widgets that Plotly 3.0 brings.

New continuous thrust/low thrust guidance laws: We brought some continuous thrust
guidance laws for orbital maneuvers that have analytical solution, such as orbit
raising combined with inclination change, eccentricity change and so forth. This is based on
the Master Thesis of Juan Luis Cano, “Study of analytical solutions for low-thrust trajectories”,
which provided complete validation for all of these laws and which
can be found on GitHub.

More natural perturbations: We finished adding the most common orbital perturbations,
namely Solar radiation pressure and J3 perturbation. We could not reach agreement with
the paper for the latter, so if you are considering using it please read the discussion
in the original pull request and
consider lending us a hand to validate it properly!

New dark mode for matplotlib plots: We added a dark parameter to
OrbitPlotter objects so the background is black.
Handy for astronomical purposes!

New experimental 2D Plotly backend: A new OrbitPlotter2D
class was introduced that uses Plotly instead of matplotlib for the rendering. There are
still some issues that should be resolved when we take advantage of the latest Plotly version,
hence the “experimental” nature.

New propagators: A new Keplerian propagator mean_motion()
was introduced that has better convergence properties than kepler(),
so now the user can choose.

New perturbation functions: A new module poliastro.twobody.perturbations was introduced
that contains perturbation accelerations that can be readily used with
cowell(). So far we implemented J2 and atmospheric drag effects,
and we will add more during the summer. Check out the User Guide for examples!

Support for different propagators in sampling: With the introduction of new propagators and perturbation
accelerations, now the user can easily sample over a period of time using any of them. We are eager to see
what experiments you come up with!

Easy plotting of the Solar System: A new function plot_solar_system() was
added to easily visualize our inner or complete Solar System in 2D plots.

poliastro participates in Google Summer of Code thanks to OpenAstronomy!
More information in the poliastro blog.

poliastro will be presented at the Python in Astronomy 2018 workshop to be held
at Center for Computational Astrophysics at the Flatiron Institute in New York, USA.
You can read more details about the event here.

Sampling method for Orbit objects that returns
an array of positions. This was already done in the plotting functions and will
help providing other applications, such as exporting an Orbit to other formats.

3D plotting functions: finally poliastro features a new high level object,
poliastro.plotting.OrbitPlotter3D, that uses Plotly to represent
orbit and trajectories in 3D. The venerable notebook about the trajectory of
rover Curiosity has been updated accordingly.

Hyperbolic anomaly conversion: we implemented the conversion of hyperbolic
to mean and true anomaly to complement the existing eccentric anomaly functions
and improve the handling of hyperbolic orbits in poliastro.twobody.angles.

NEOS package: a new package has been added to poliastro, neos
package. It provides several ways of getting NEOs (Near Earth Objects) data from NASA
databases, online and offline.

New patched conics module. New module containing a function to compute
the radius of the Sphere of Influence (SOI).

Use Astropy for body ephemerides. Instead of downloading the SPK
files ourselves, now we use Astropy builtin capabilities. This also
allows the user to select a builtin ephemerides that does not require
external downloads. See #131 for details.

Coordinates and frames modules: new modules containing transformations between ICRS
and body-centered frame, and perifocal to body_centered, coordinates
as well as Heliocentric coordinate frame in frames based on Astropy
for NEOs.

Pip packaging: troublesome dependencies have been released in wheel format,
so poliastro can now be installed using pip from all platforms.

Legend plotting: now label and epoch are in a figure legend, which ends with
the ambiguity of the epochs when having several plots in the same figure.

Introduced ``Orbit`` objects to replace State ones. The latter
has been simplified, reducing some functionality, now their API
has been moved to the former. See the User Guide and the examples for
updated explanations. See #135.

Allow propagation functions to receive a callback. This paves the
way for better plotting and storage of results. See #140.

Drop Legacy Python: poliastro 0.5.x and later will support only
Python 3.x. We recommend our potential users to create dedicated virtual
environments using conda or virtualenv or to contact the developers to fund
Python 2 support.

Change ``lambert`` function API: The functions for solving Lambert’s
problem are now _generators_, even in the single revolution case.
Check out the User Guide for specific examples.

Creation of orbits from classical elements: poliastro has
reverted the switch to the semilatus rectum \(p\) instead of the semimajor
axis \(a\) made in 0.4.0, so \(a\) must be used again. This change is
definitive.

This is a new major release, focused on improving stability and code quality.
New angle conversion and modified equinoctial elements functions were added
and an important backwards incompatible change was introduced related to
classical orbital elements.

Creation of orbits from classical elements: poliastro has
switched to the semilatus rectum \(p\) instead of the semimajor
axis \(a\) to define State objects, and the function has been renamed
to from_classical(). Please update your
programs accordingly.

Removed specific angular momentum \(h\) property to avoid a name clash
with the fourth modified equinoctial element, use norm(ss.h_vec)
instead.

Pure Python codebase: Forget about Fortran linking problems and
nightmares on Windows, because now poliastro is a pure Python package.
A new dependency, numba, was introduced to accelerate the algorithms,
but poliastro will use it only if it is installed.

Lambert problem solving: New module iod to
determine an orbit given two position vectors and the time of flight.

PR #42: Planetary ephemerides computation: New module
ephem with functions to deal with SPK files and
compute position and velocity vectors of the planets.