Classy-blocks

Added
- Channel example
- Cyclone example
- Mirror transform on points, operations, shapes, mirror example
- Operation:
- `get_closest_face()`, `get_closest_side()`, `get_normal_face()`
- Connector operation
- Geometric finders: find_on_plane()
- functions.point_to_line_distance()

Changed
- Optimization improvements:
- Default parameters for clamp optimization
- Clamps are sorted by sensitivity, not "junction quality" as before (improves optimization speed)
- Clamp parameters follow domain scale (Read more below)
- Raise an Exception when adding more than one Clamp for the same vertex

Clamp Parameters:
Previously:
- RadialClamp had a single parameter, the _angle_ of the point (and change thereof)
- In Linelamp the parameter _t_ went from 0 to 1 regardless of the distance between points

This created difficulties with optimization algorithms with extra large or very small domains.
Optimization speed also drastically changing with simply scaling the dimensions.

This has been changed:
- RadialClamp's parameter is now multiplied with radius so it means actual _distance_
- LineClamp's parameter now goes from 0 to _distance between points_
When working with CurveClamps, this kind of _automatic_ correction cannot be made so it is advisable
that parameter is of a similar magnitudes than points' coordinates.

Removed
- Junction.delta() is now handled by optimization automatically

Added
- Airfoil example
- Translation and Rotational Link: move together with vertices being optimized (see the airfoil example)

Changed
- Renamed ParametricCurveClamp to CurveClamp (takes Curve object of any kind)
- Interpolated curves' indexes are now between 0 and 1 (easier to work with than using len(points) every time)
- Optimization driver:
- Termination tolerance is now based on initial improvement instead of quality
- Relaxation starts at 0.5 by default and increases linearly to 1 in a given number of relaxed iterations

Removed
- Curve.get_closest_param() now finds initial_param automatically

Added
- *Curve objects for dealing with edge specification and optimization

Added
- mesh.clear() removes lists of all items that were populated during mesh.assemble()
- mesh.backport() updates user supplied operations' points with results of optimization/modification

Changed
- Optimizer: under-relaxation for the first optimization iterations

Added
- **Blocking Optimization**
- Finders for easier fetching vertices, generated by mesh.assemble()
- GeometricFinder lists vertices inside searchable geometric entities
- RoundSolidFinder identifies vertices on core/shell of round solids
- An Optimizer class that handles blocking optimization
- Clamp classes that define degrees of freedom of optimizing points:
- Free (3 DoF)
- Slide along a curve (line, parametric curve) (1 DoF)
- Move on a surface (parametric surface) (2 DoF)
- **Reorienting Operations and Faces**
- `Face`:
- `shift()` method to rotate points around
- `reorient()` method that rotates points so that they start nearest to given position
- `ViewpointOrienter`: a class for auto-orienting operation's points based on specified points 'in front' and 'above' the operation.

Changed
- Projection Behaviour
- Calling .project() on a Point/Vertex will add the new geometry instead of replacing it.
- Calling .project_edge() on an Operation will add the new geometry instead of replacing it.
- Calling .project_side() on an Operation will add the new geometry to edges instead of replacing them (but will replace existing label for the side)

Added
- A Shell Shape, created from arbitrary set of faces
Changed
- Operation.get_face() will not auto-reorder faces (causes confusion for users)
Fixed
- A bug where Operation.project_face(..., points=True) won't project vertices

[1. 1. 0] Default Extrude Direction
Added
- Extrude now takes a vector of a float. If a float is given, direction is normal of the base face.

[1. 0. 0] Refactor
A complete overhaul of all objects in an attempt to create a proper SOLID-obeying
package with type hinting, static typing and no python-ish duck-typing hacks.

Added
- examples and showcases from `classy_examples` repo
- static type analysis, formatting, linting
- Origin and Angle edges (Foundation and ESI alternatives to arc)
- Projection of vertices to geometry
- Import convention `import classy_blocks as cb` and direct imports of user-usable objects from `cb`, like `cb.Mesh, cb.Loft, cb.Arc`
- `Operation.faces` property that creates new faces on-the-fly for easier chaining of new operations
- A Frame object that simplifies addressing edges/wires/other stuff between pairs of vertices on a hexahedron
- ExtrudedRing.fill() method has been added to create cylinders inside rings
Changed
- Major package layout refactor
- Edge specification (Arc, Origin, Angle, Project, Spline, PolyLine objects)
- Reverted Face specification for operations
- The Block object is not directly available to the user as it makes no sense to do so
- Import convention: `import classy_blocks as cb` for examples
- Changed examples so that an example file runs directly instead of calling run.py (that created a lot of confusion)
- Box() is now an operation (previously Shape)
- simplified cylinder and sphere creation
- Chaining of elbows/cylinders/etc always with start_face parameters (instead of negative length)
Removed
- *Wall shapes will be created later with a different approach
- Examples with *Wall shapes will be recreated later with new approaches
- airfoil2d example requires blocking optimization so it will be recreated when that feature is available
- sphere example will be recreated when 'offset' is available
- block.from_points has been removed (use Loft)
- T-joint will be added when a skew transform is implemented