wassily_geometry/lib.rs
1//! # Wassily Geometry
2//!
3//! **Advanced geometric operations and spatial data structures for generative art.**
4//! This crate provides sophisticated tools for working with curves, grids, spatial
5//! data structures, and subdivision algorithms essential for creating complex
6//! geometric patterns and algorithmic art.
7//!
8//! ## Key Features
9//!
10//! - **Parametric Curves**: Arc-length parameterized paths with interpolation and refinement
11//! - **Spatial Data Structures**: Efficient quadtree implementation for point queries
12//! - **Subdivision Algorithms**: Recursive quadrilateral and triangle subdivision with noise
13//! - **Matrix Operations**: Generic matrix with convolution, multiplication, and linear algebra
14//! - **Specialized Lines**: Artistic line effects including fade, sand, and stipple textures
15//! - **Grid Systems**: Structured point grids with quadrilateral extraction
16//!
17//! ## Quick Start
18//!
19//! ```no_run
20//! use wassily_geometry::*;
21//! use wassily_core::points::pt;
22//!
23//! // Create a parametric curve
24//! let points = vec![pt(0.0, 0.0), pt(100.0, 50.0), pt(200.0, 0.0)];
25//! let curve = ParametricPath::new(points);
26//! let midpoint = curve.point_at(0.5); // Get point at 50% along curve
27//!
28//! // Subdivision example
29//! let quad = Quad::new(pt(0.0, 0.0), pt(0.0, 100.0), pt(100.0, 100.0), pt(100.0, 0.0));
30//! let (left, right) = quad.split_v(0.3, 0.7);
31//!
32//! // Quadtree for spatial queries
33//! let mut qtree = QNode::new(vec![pt(10.0, 10.0), pt(90.0, 90.0)], pt(0.0, 0.0), pt(100.0, 100.0));
34//! let nearby = qtree.points_in_circle(pt(0.0, 0.0), pt(100.0, 100.0), pt(50.0, 50.0), 25.0);
35//! ```
36//!
37//! ## Core Components
38//!
39//! ### Curves and Paths
40//!
41//! - **[`ParametricPath`]**: Arc-length parameterized curves with uniform sampling
42//! - **[`curve`]**: Generate smooth curves from mathematical functions
43//! - **[`refine`]**: Adaptive curve refinement for optimal approximation quality
44//!
45//! ### Spatial Data Structures
46//!
47//! - **[`QNode`]**: Quadtree for efficient spatial queries and nearest neighbor searches
48//! - **[`Grid`]**: Structured point grids with quadrilateral mesh extraction
49//!
50//! ### Subdivision Algorithms
51//!
52//! - **[`Quad`]**: Quadrilateral subdivision with customizable split strategies
53//! - **[`Tri`]**: Triangle subdivision for triangular mesh generation
54//! - **[`warp_points`]**: Noise-based point perturbation for organic distortion
55//!
56//! ### Matrix and Linear Algebra
57//!
58//! - **[`Matrix`]**: Generic matrix operations including convolution and multiplication
59//! - Zero-indexed, row-major storage with comprehensive operation support
60//!
61//! ### Artistic Line Effects
62//!
63//! - **[`FadeLine`]**: Lines with variable opacity subdivisions
64//! - **[`SandLine`]**: Textured lines with grain-like appearance
65//! - **[`DotLine`]**: Stippled lines with noise-based dot placement
66//!
67//! ## Applications
68//!
69//! - **Algorithmic Art**: Recursive subdivision patterns and fractal-like structures
70//! - **Mesh Generation**: Quadrilateral and triangular mesh creation with organic distortion
71//! - **Spatial Queries**: Efficient point location and nearest neighbor operations
72//! - **Curve Manipulation**: Smooth interpolation and adaptive curve approximation
73//! - **Pattern Generation**: Grid-based patterns with artistic line rendering
74//!
75//! ## Examples
76//!
77//! ### Recursive Subdivision
78//!
79//! ```no_run
80//! use wassily_geometry::*;
81//! use wassily_core::points::pt;
82//!
83//! // Create initial quad
84//! let quad = Quad::new(pt(0.0, 0.0), pt(0.0, 100.0), pt(100.0, 100.0), pt(100.0, 0.0));
85//! let mut quads = vec![quad];
86//!
87//! // Recursively subdivide
88//! for _ in 0..5 {
89//! quads = quad_divide_vec(
90//! &quads,
91//! |q| q.best_dir(), // Split along longest dimension
92//! |_| (0.4, 0.6), // Split ratios
93//! );
94//! }
95//! ```
96//!
97//! ### Parametric Curve Interpolation
98//!
99//! ```no_run
100//! use wassily_geometry::*;
101//! use wassily_core::points::pt;
102//!
103//! // Define control points
104//! let points = vec![
105//! pt(0.0, 50.0),
106//! pt(25.0, 100.0),
107//! pt(75.0, 0.0),
108//! pt(100.0, 50.0),
109//! ];
110//!
111//! let path = ParametricPath::new(points);
112//!
113//! // Sample points uniformly along curve length
114//! let samples: Vec<_> = (0..=20)
115//! .map(|i| path.point_at(i as f32 / 20.0))
116//! .collect();
117//! ```
118//!
119//! ### Spatial Indexing with Quadtree
120//!
121//! ```no_run
122//! use wassily_geometry::*;
123//! use wassily_core::points::pt;
124//!
125//! // Build quadtree with scattered points
126//! let points = vec![
127//! pt(10.0, 10.0), pt(25.0, 80.0), pt(90.0, 30.0),
128//! pt(45.0, 45.0), pt(70.0, 15.0), pt(30.0, 90.0),
129//! ];
130//!
131//! let qtree = QNode::new(points, pt(0.0, 0.0), pt(100.0, 100.0));
132//!
133//! // Find all points within radius of query point
134//! let query_center = pt(50.0, 50.0);
135//! let radius = 30.0;
136//! let nearby = qtree.points_in_circle(
137//! pt(0.0, 0.0), pt(100.0, 100.0),
138//! query_center, radius
139//! );
140//! ```
141
142pub mod curves;
143pub mod grid;
144pub mod lines;
145pub mod matrix;
146pub mod quadtree;
147pub mod subdivision;
148
149// Re-export key types and functions for convenience
150pub use curves::*;
151pub use grid::*;
152pub use lines::*;
153pub use matrix::*;
154pub use quadtree::*;
155pub use subdivision::*;