# SimpleOrbit Class

### Class Initialization

```python
class SimpleOrbit(FeaturesExtra):
    def __init__(self, plot_title, name, fps=30):
```

* `plot_title` (str): The title of the orbital plot.
* `name` (str): The name of the celestial object you want to plot.
* `fps` (int): Frames per second for the animation (default is 30).

This class is initialized with a plot title, object name, and an optional frames per second value for the animation.

### Plot Styling

#### Setting Background Color

```python
def faceColor(self, face_color):
```

* `face_color` (str): Background color of the 3D plot.

Set the background color of the plot using this method. You can specify the color as a name (e.g., "white") or a hexadecimal code (e.g., "#F3EEEA").

#### Setting Axes Plane Color

```python
def paneColor(self, pane_color):
```

* `pane_color` (str): Color of the axes planes.

Change the color of the planes representing the X, Y, and Z axes using this method.

#### Setting Grid Color

```python
def gridColor(self, grid_color):
```

* `grid_color` (str): Color of grid lines.

Customize the color of the grid lines in the 3D plot to provide reference points.

#### Setting Orbit Transparency

```python
def orbitTransparency(self, orbit_transparency):
```

* `orbit_transparency` (float): Transparency of orbit lines (0.0 to 1.0).

Control the transparency of the plotted orbit lines. A value of 0.0 means fully transparent, while 1.0 means fully opaque.

#### Setting Label Color

```python
def labelColor(self, label_color):
```

* `label_color` (str): Color of axis labels.

Customize the color of the X, Y, and Z axis labels for better visibility or style matching.

#### Setting Tick Color

```python
def tickColor(self, tick_color):
```

* `tick_color` (str): Color of axis ticks.

Specify the color of the ticks on the X, Y, and Z axes to align them with the plot's style.

### Data Input and Plot Generation

#### Generating Orbital Plot

```python
def calculateOrbit(self, plot_steps, n_orbits, data=None, color=None, trajectory=False, sun=True):
```

* `plot_steps` (int): Number of steps for plotting the orbit.
* `n_orbits` (int): Number of orbital periods to plot.
* `data` (list of lists): List of celestial objects' data. Each sublist should contain the name, semi-major axis, perihelion, eccentricity, inclination, longitude of ascending node, argument of perihelion, and color (optional).
* `color` (str): Default color for celestial objects (optional).
* `trajectory` (bool): Whether to plot the object's trajectory (default is False).
* `sun` (bool): Whether to plot the Sun at the center (default is True).
* `inclinationObserver` (bool): Visualize the inclination of the orbits
* `display_name` (bool): Enable the names/IDs of the objects you are plotting.

Use this method to generate 3D orbital plots. You can either provide a list of celestial object data or specify the orbital parameters individually for a single object.

#### Animating the Orbit

```python
def animateOrbit(self, dpi, save=False, export_zoom=None, font_size="xx-small", export_folder=None, animation_interval=40, x_lim=None, y_lim=None, z_lim=None, x_label="X-Axis", y_label="Y-Axis", z_label="Z-Axis"):
```

* `dpi` (int): Dots per inch for the animation.
* `save` (bool): Whether to save the animation as a GIF (default is False).
* `export_zoom` (int): Zoom level for the exported GIF (optional).
* `font_size` (str): Font size for the legend (optional).
* `export_folder` (str): Folder to save the GIF (optional).
* `animation_interval` (int): Interval between animation frames (default is 40).
* `x_lim` (list): List containing the X-axis limits (optional).
* `y_lim` (list): List containing the Y-axis limits (optional).
* `z_lim` (list): List containing the Z-axis limits (optional).
* `x_label` (str): Label for the X-axis (optional).
* `y_label` (str): Label for the Y-axis (optional).
* `z_label` (str): Label for the Z-axis (optional).

This method animates the generated orbital plot. You can specify various parameters like export settings, axis labels, and animation interval.

#### Setting Axis Limits

```python
def xLim(self, x_lim):
def yLim(self, y_lim):
def zLim(self, z_lim):
```

* `x_lim`, `y_lim`, `z_lim` (list): Lists containing axis limits.

You can use these methods to set custom limits for the X, Y, and Z axes to focus on specific regions of the plot.

#### Setting Axis Labels

```python
def xLabel(self, x_label):
def yLabel(self, y_label):
def zLabel(self, z_label):
```

* `x_label`, `y_label`, `z_label` (str): Labels for the X, Y, and Z axes.

Use these methods to label the axes in the plot with the desired text.

### Individual Object Details

You can set individual orbital parameters for a single object using the following methods:

```python
def semiMajorAxis(self, semi_major_axis):
def perihelion(self, perihelion):
def eccentricity(self, eccentricity):
def inclination(self, inclination):
def longitudeOfAscendingNode(self, longitude_of_ascending_node):
def argumentOfPerihelion(self, argument_of_perihelion):
def sunSize(self, sun_size):
def planetSize(self, planet_size):
```

* `semi_major_axis`: Semi-major axis of the object's orbit.
* `perihelion`: Perihelion distance of the object's orbit.
* `eccentricity`: Eccentricity of the object's orbit.
* `inclination`: Inclination of the object's orbit.
* `longitude_of_ascending_node`: Longitude of the ascending node of the object's orbit.
* `argument_of_perihelion`: Argument of perihelion of the object's orbit.
* `sun_size`: Size of the Sun in the plot.
* `planet_size`: Size of the celestial object in the plot.

### Inclination Plot

```python
def inclinationPlot(self, color):
```

* `color` (str): Color of the inclination plot.

Use this method to enable plotting of inclination and specify the color for the inclination plot.

### Example Usage

```python
# Import the SimpleOrbit class and other required libraries
from orbitronomy import SimpleOrbit

# Create a SimpleOrbit object with a plot title and object name
test = SimpleOrbit(plot_title="Test", name="Earth", fps=30)

# Styling the plot
test.faceColor("black")
test.paneColor("black")
test.gridColor("#222831")
test.orbitTransparency(0.5)
test.labelColor("white")
test.tickColor("white")
test.plotStyle(background_color="dark_background")

# Define data for multiple celestial objects or set parameters individually for a single object
data = [
    ["object1", 1, 0.983289891, 0.01671123, 15, 0, 0, "green"],
    ["object2", 1.5, 0.483289891, 0.02671123, 6, 0, 0, "yellow"],
    ["object3", 1.3, 0.683289891, 0.01671123, 2, 0, 0, "red"]
]

# cool atom shape
# data = [
#     ['electron1', 1.0, 0.8, 0.2, 0.0, 0, 0, 'red'],
#     ['electron2', 1.0, 0.8, 0.2, 30.0, 0, 0, 'red'],
#     ['electron3', 1.0, 0.8, 0.2, 60.0, 0, 0, 'red'],
#     ['electron4', 1.0, 0.8, 0.2, 90.0, 0, 0, 'red'],
#     ['electron5', 1.0, 0.8, 0.2, 120.0, 0, 0, 'red'],
#     ['electron6', 1.0, 0.8, 0.2, 150.0, 0, 0, 'red']]

# cool atom shape 2x less
# data = [
#     ['electron1', 1.0, 0.2, 0.6, 0.0, 0, 0, 'red'],
#     ['electron2', 1.0, 0.2, 0.6, 60.0, 0, 0, 'red'],
#     ['electron3', 1.0, 0.2, 0.6, 120.0, 0, 0, 'red'],
# ]


# you can also use the following instead of data if you want to plot a single object
# test.semiMajorAxis(1)
# test.perihelion(0.983289891)
# test.eccentricity(0.01671123)
# test.inclination(0)
# test.longitudeOfAscendingNode(0)
# test.argumentOfPerihelion(0)


# Calculate and plot the orbits
test.sunSize(1000)
test.planetSize(100)

# Enable inclination observation plot with red color
test.inclinationPlot(color="red")


test.calculateOrbit(plot_steps=1000, n_orbits=4, data=data,
                    # color="blue",
                    trajectory=True, sun=True, 
                    inclinationObserver=False, 
                    display_name=True, fontsize=12, fontweight="normal")


# Set axis labels and limits
test.xLabel("X-Axis")
test.yLabel("Y-Axis")
test.zLabel("Z-Axis")
test.xLim([20, 20])
test.yLim([20, 20])
test.zLim([1, 1])

# Animate and save the orbit plot as a GIF
test.animateOrbit(dpi=250, save=False, export_zoom=3, font_size="xx-small", export_folder="results", animation_interval=10)
```

This example demonstrates how to create and customize orbital plots using the `SimpleOrbit` class. You can define data for multiple celestial objects or set parameters individually for a single object, style the plot, and generate an animated orbit visualization.