wingwalker 1.1.0
Wingwalker Airfoil and Wing Design Tools'
Requires Python: >=3.11

# Wingwalker Python Module

This Python module provides core functions and scripts to create useful airfoil models
and files from engineering specifications.  These base models can then be used to 
create useful designs and implementations (VR and 3D models, 3D printer components, etc).

## Philosophy

Wing selection and design can be very complex.  From the choice of starting
airfoil specs (custom or existing), to cost analysis, and finally to construction, the spectrum of
both choices and pitfalls at each stage can become overwhelming pretty quickly, especially to 
someone whose primary interest is what comes _after_ the wings are bolted on. 

The goal behind this software is very straightforward:  To give everyone, from 
the basic hobbyist to the serious (semi)professional, the ability to go quickly from theory and
specs to design to real- or virtual-world production of airfoils and wings.

Wingwalker is modeled to make the process from airfoil selection to printable model as simple and straightforward
as possible.  For most use cases, the simplest approach, demonstrated in the examples, should be sufficient.  Those with more
strict or customized requirements still have access to the underlying steps, and can build up a more detailed workflow, in accordance
with their needs.

## Installation

```bash
$ pip install wingwalker
```

## Usage

The following code snippet shows how to take various inputs, create a `WingRequest`, pass that to the module functions,
and then display and export the resulting wing point cloud.

```python
from pyvista import PolyData, Plotter
from wingwalker.models.wing_model import WingModel, WingRequest
from wingwalker.generators.wing import generate_wing_model, generate_point_cloud_polydata
from wingwalker.io.exports import export_ply


def plot_results(model: WingModel, points: PolyData):
    title = f'Point Cloud\n\n{model.wing_params.wing_type}\n{model.wing_params.planform.name}'
    pl = Plotter(shape=(1, 1))
    pl.add_title(title, color='grey')
    pl.background_color = 'black'
    point_view = pl.add_mesh(
        mesh=points,
        style='points',
        line_width=0.1,
        point_size=1.5,
        color='yellow',
        opacity=0.7
    )
    pl.show()


def main(planform, wing_type, span, base, end, twist, specfile, spec_format, iterations):
    req: WingRequest = WingRequest()
    req.planform = planform
    req.wing_type = wing_type
    req.span = span
    req.base_chord = base
    req.end_chord = end
    req.twist = twist
    req.spec_file = specfile
    req.spec_format = spec_format
    req.iterations = iterations

    print()

    # Generate and preview a point cloud for the model
    model = generate_wing_model(wing_req=req)
    p_cloud: PolyData = generate_point_cloud_polydata(model)
    plot_results(model, p_cloud)

    # Export the model to PLY format
    export_name = f'wing_{wing_type}_{planform}.ply'
    export_ply(model, export_name)
```

## Generating STL files

The process too generate an STL file for processing or sending to a 3D printer is very simple. This script shows the entire process.

The requirements for the wing STL file are stored in `elliptical_left_wing_256mm.json`.  This python script
parses the request, parses the designated airfoil specs, and then steps through the process to generate an elliptical wing
of the given dimensions.

```python
import os

from wingwalker.build_params.wing_request import WingRequest
from wingwalker.generators.wing import get_airfoil_specs, get_lambdas, generate_wing
from wingwalker.io.exports import export_stl

config_file = 'elliptical_left_wing_256mm.json'

# Read the values from the file
wing_req: WingRequest
with open(config_file, 'r', encoding='utf-8') as fin:
    json_str = fin.read()
    wing_req = WingRequest.from_json(json_str)

# Retrieve the specs from the request path
af_specs = get_airfoil_specs(wing_req)

# Get lambdas (dimension functions for the given parameters)
c_func, t_func, z_func, area_func = get_lambdas(wing_req)

# Generate the actual wing model
model = generate_wing(wing_req, af_specs, c_func, t_func, z_func, area_func)

f_name = f'{wing_req.name}_geometric_wing.stl'
if os.path.exists(f_name):
    os.remove(f_name)

export_stl(model, f_name)

print('Aircraft wing STL file generated.')

print(model.__repr__())
```


## License

This software is distributed freely under the MIT license.  You are free to use, abuse, modify, 
or ridicule the software, its products, and its processes in any way you see fit.

Output generated by the original software is published under the Create Commons license, and may
also be used for any purpose, commercial or not.  Users of this software may freely apply or replace the CC 
license with their own license or restrictions, as they desire.

## Credits

`wingwalker` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).