501 lines
13 KiB
Rust
501 lines
13 KiB
Rust
//! All supported GEGL operations.
|
|
|
|
mod enums;
|
|
mod macros;
|
|
|
|
pub use enums::*;
|
|
|
|
pub use crate::gegl_operation;
|
|
|
|
gegl_operation!(
|
|
struct_name: Bloom,
|
|
gegl_name: "bloom",
|
|
append_crop: false,
|
|
values: (
|
|
/// Don't over-expose highlights.
|
|
limit_exposure: bool, false,
|
|
/// Glow radius.
|
|
radius: f64, 10.0,
|
|
/// Glow-area edge softness.
|
|
softness: f64, 25.0,
|
|
/// Glow strength.
|
|
strength: f64, 50.0,
|
|
/// Glow-area brightness threshold.
|
|
threshold: f64, 50.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Cartoon,
|
|
gegl_name: "cartoon",
|
|
append_crop: true,
|
|
values: (
|
|
/// The mask radius.
|
|
mask_radius: f64, 7.0,
|
|
/// The percentage of black.
|
|
pct_black: f64, 0.2,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: CellNoise,
|
|
gegl_name: "cell-noise",
|
|
append_crop: true,
|
|
values: (
|
|
/// The number of noise octaves.
|
|
iterations: i64, 1,
|
|
/// Fill each cell with a random color.
|
|
palettize: bool, false,
|
|
/// Select the n-th closest point
|
|
rank: i64, 1,
|
|
/// The scale of the noise function.
|
|
scale: f64, 1.0,
|
|
/// The random seed for the noise function.
|
|
seed: f64, 0.0,
|
|
/// Interpolate between Manhattan and Euclidean distance.
|
|
shape: f64, 2.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Crop,
|
|
gegl_name: "crop",
|
|
append_crop: false,
|
|
values: (
|
|
/// The wanted height of the buffer.
|
|
height: f64, 0.0,
|
|
/// Reset the origin for the coordinates.
|
|
reset_origin: bool, false,
|
|
/// The wanted width of the buffer.
|
|
width: f64, 0.0,
|
|
/// The X coordinate to start from.
|
|
x: f64, 0.0,
|
|
/// The Y coordinate to start from.
|
|
y: f64, 0.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: DiffractionPatterns,
|
|
gegl_name: "diffraction-patterns",
|
|
append_crop: true,
|
|
values: (
|
|
/// Number of contours (blue);
|
|
blue_contours: f64, 0.97,
|
|
/// Light frequency (blue).
|
|
blue_frequency: f64, 1.12,
|
|
/// Number of sharp edges (blue).
|
|
blue_sedges: f64, 0.64,
|
|
/// Brightness and shifting/fattening of contours.
|
|
brightness: f64, 0.07,
|
|
/// Number of contours (green);
|
|
green_contours: f64, 0.82,
|
|
/// Light frequency (green).
|
|
green_frequency: f64, 1.22,
|
|
/// Number of sharp edges (green).
|
|
green_sedges: f64, 0.68,
|
|
/// Height of the generated buffer.
|
|
height: i64, 200,
|
|
/// Polarization.
|
|
polarization: f64, -0.47,
|
|
/// Number of contours (red);
|
|
red_contours: f64, 0.82,
|
|
/// Light frequency (red).
|
|
red_frequency: f64, 0.81,
|
|
/// Number of sharp edges (red).
|
|
red_sedges: f64, 0.61,
|
|
/// Scattering (speed vs. quality).
|
|
scattering: f64, 37.13,
|
|
/// Width of the generated buffer.
|
|
width: i64, 200,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Edge,
|
|
gegl_name: "edge",
|
|
append_crop: false,
|
|
values: (
|
|
/// The edge detection algorithm to use.
|
|
algorithm: EdgeAlgorithm, EdgeAlgorithm::Sobel,
|
|
/// The amount of edge detection to perform.
|
|
amount: f64, 2.0,
|
|
/// The edge detection border behavior.
|
|
border_behavior: AbyssPolicy, AbyssPolicy::Clamp,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: EdgeNeon,
|
|
gegl_name: "edge-neon",
|
|
append_crop: false,
|
|
values: (
|
|
/// Strength of effect.
|
|
amount: f64, 0.0,
|
|
/// Radius of effect in pixels.
|
|
radius: f64, 5.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: FocusBlur,
|
|
gegl_name: "focus-blur",
|
|
append_crop: false,
|
|
values: (
|
|
/// The aspect ratio of the focus region.
|
|
aspect_ratio: f64, 0.0,
|
|
/// Out-of-focus blur radius.
|
|
blur_radius: f64, 25.0,
|
|
/// The blur type.
|
|
blur_type: FocusBlurType, FocusBlurType::Gaussian,
|
|
/// The focus region's inner limit.
|
|
focus: f64, 0.25,
|
|
/// Relative highlight strength.
|
|
highlight_factor: f64, 0.0,
|
|
/// Highlight threshold (high).
|
|
highlight_threshold_high: f64, 1.0,
|
|
/// Highlight threshold (low).
|
|
highlight_threshold_low: f64, 0.0,
|
|
/// Generate more accurate and consistent output.
|
|
high_quality: bool, false,
|
|
/// The focus region's transition midpoint.
|
|
midpoint: f64, 0.5,
|
|
/// The focus region's outer radius.
|
|
radius: f64, 0.75,
|
|
/// The rotation of the focus region.
|
|
rotation: f64, 0.0,
|
|
/// The blur shape.
|
|
shape: FocusBlurShape, FocusBlurShape::Circle,
|
|
/// The X coordinate for the center of the blur.
|
|
x: f64, 0.5,
|
|
/// The Y coordinate for the center of the blur.
|
|
y: f64, 0.5,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Maze,
|
|
gegl_name: "maze",
|
|
append_crop: false,
|
|
values: (
|
|
/// Maze algorithm type
|
|
algorithm_type: MazeAlgorithmType, MazeAlgorithmType::DepthFirst,
|
|
/// The background color.
|
|
bg_color: String, "#fff".to_string(),
|
|
/// The foreground color.
|
|
fg_color: String, "#000".to_string(),
|
|
/// The random seed.
|
|
seed: f64, 0.0,
|
|
/// Whether the maze should be tileable.
|
|
tileable: bool, false,
|
|
/// Horizontal width of cells pixels.
|
|
x: i64, 16,
|
|
/// Vertical width of cells pixels.
|
|
y: i64, 16,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: MedianBlur,
|
|
gegl_name: "median-blur",
|
|
append_crop: false,
|
|
values: (
|
|
/// How image edges are handled.
|
|
abyss_policy: MedianBlurAbyssPolicy, MedianBlurAbyssPolicy::Clamp,
|
|
/// Neighborhood alpha percentile.
|
|
alpha_percentile: f64, 50.0,
|
|
/// Avoid clipping and quantization
|
|
high_precision: bool, false,
|
|
/// Neighborhood type.
|
|
neighborhood: MedianBlurNeighborhood, MedianBlurNeighborhood::Circle,
|
|
/// Neighborhood color percentile.
|
|
percentile: f64, 50.0,
|
|
/// Neighborhood radius, a negative value will calculate with inverted
|
|
/// percentiles.
|
|
radius: f64, 3.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Mirrors,
|
|
gegl_name: "mirrors",
|
|
append_crop: false,
|
|
values: (
|
|
/// Clip result to input size.
|
|
clip: bool, true,
|
|
/// X coordinate of symmetry center in output.
|
|
c_x: f64, 0.5,
|
|
/// Y coordinate of symmetry center in output.
|
|
c_y: f64, 0.5,
|
|
/// Scale factor to make rendering size bigger.
|
|
input_scale: f64, 100.0,
|
|
/// Rotation applied to the mirrors.
|
|
m_angle: f64, 0.0,
|
|
/// Number of mirrors to use.
|
|
n_segs: i64, 6,
|
|
/// Scale factor to make rendering size bigger.
|
|
output_scale: f64, 1.0,
|
|
/// X axis ratio for the center of mirroring
|
|
o_x: f64, 0.0,
|
|
/// Y axis ratio for the center of mirroring
|
|
o_y: f64, 0.0,
|
|
/// Rotation applied to the result.
|
|
r_angle: f64, 0.0,
|
|
/// X axis ratio for trimming mirror expanse
|
|
trim_x: f64, 0.0,
|
|
/// Y axis ratio for trimming mirror expanse
|
|
trim_y: f64, 0.0,
|
|
/// Fill full output area.
|
|
warp: bool, true,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Mosaic,
|
|
gegl_name: "mosaic",
|
|
append_crop: false,
|
|
values: (
|
|
/// Enables smoother tile output.
|
|
antialiasing: bool, true,
|
|
/// Tile color based on average of subsumed pixels.
|
|
color_averaging: bool, true,
|
|
/// Magnitude of random color variations.
|
|
color_variation: f64, 0.2,
|
|
/// Joints color.
|
|
joints_color: String, "#000".to_string(),
|
|
/// Light color.
|
|
light_color: String, "#fff".to_string(),
|
|
/// Direction of light-source (in degrees).
|
|
light_dir: f64, 135.0,
|
|
/// Random seed.
|
|
seed: f64, 0.0,
|
|
/// Allows splitting tiles at hard edges.
|
|
tile_allow_split: bool, true,
|
|
/// Apparent height of each tile (in pixels).
|
|
tile_height: f64, 4.0,
|
|
/// Deviation from perfectly formed tiles.
|
|
tile_neatness: f64, 0.65,
|
|
/// Average diameter of each tile (in pixels).
|
|
tile_size: f64, 15.0,
|
|
/// Inter-tile spacing (in pixels).
|
|
tile_spacing: f64, 1.0,
|
|
/// Surface characteristics.
|
|
tile_surface: bool, false,
|
|
/// What shape to use for tiles.
|
|
tile_type: MosaicTileType, MosaicTileType::Hexagons,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Newsprint,
|
|
gegl_name: "newsprint",
|
|
append_crop: false,
|
|
values: (
|
|
/// Number of samples that are averaged for antialiasing the result.
|
|
aa_samples: i64, 16,
|
|
/// Black angle.
|
|
angle: f64, 75.0,
|
|
/// Red and cyan angle.
|
|
angle2: f64, 15.0,
|
|
/// Green and magenta angle.
|
|
angle3: f64, 45.0,
|
|
/// Blue and yellow angle.
|
|
angle4: f64, 0.0,
|
|
/// Multiplication factor for desired rotation of the local space for
|
|
/// texture, the way this is computed makes it weak for desaturated colors
|
|
/// and possibly stronger where there is color.
|
|
angleboost: f64, 0.0,
|
|
/// How much of common gray to pull out of CMY.
|
|
black_pullout: f64, 1.0,
|
|
/// Number of periods per tile, this tiling avoids high frequency anomaly
|
|
/// that angle boost causes.
|
|
blocksize: f64, -1.0,
|
|
/// How many inks to use.
|
|
color_model: NewsprintColorModel, NewsprintColorModel::BlackOnWhite,
|
|
/// Black halftoning/dot pattern to use.
|
|
pattern: NewsprintPattern, NewsprintPattern::Line,
|
|
/// Red and cyan halftoning/dot pattern to use.
|
|
pattern2: NewsprintPattern, NewsprintPattern::Line,
|
|
/// Green and magenta halftoning/dot pattern to use.
|
|
pattern3: NewsprintPattern, NewsprintPattern::Line,
|
|
/// Blue and yellow halftoning/dot pattern to use.
|
|
pattern4: NewsprintPattern, NewsprintPattern::Line,
|
|
/// Black number of pixels across one repetition of a base pattern at base
|
|
/// resolution.
|
|
period: f64, 12.0,
|
|
/// Red and cyan number of pixels across one repetition of a base pattern at
|
|
/// base resolution.
|
|
period2: f64, 12.0,
|
|
/// Green and magenta number of pixels across one repetition of a base pattern
|
|
/// at base resolution.
|
|
period3: f64, 12.0,
|
|
/// Blue and yellow number of pixels across one repetition of a base pattern
|
|
/// at base resolution.
|
|
period4: f64, 12.0,
|
|
/// Color saturation dependent compression of period.
|
|
turbulence: f64, 0.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: NoisePick,
|
|
gegl_name: "noise-pick",
|
|
append_crop: true,
|
|
values: (
|
|
/// Randomization percentage.
|
|
pct_random: f64, 50.0,
|
|
/// Amount of repetitions to make.
|
|
repeat: i64, 1,
|
|
/// Random seed.
|
|
seed: f64, 0.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Oilify,
|
|
gegl_name: "oilify",
|
|
append_crop: false,
|
|
values: (
|
|
/// Exponent for processing, controls smoothness.
|
|
exponent: i64, 8,
|
|
/// Histogram size.
|
|
intensities: i64, 128,
|
|
/// Radius of circle around pixel.
|
|
mask_radius: i64, 4,
|
|
/// Use pixel luminance values.
|
|
use_inten: bool, true,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Plasma,
|
|
gegl_name: "plasma",
|
|
append_crop: false,
|
|
values: (
|
|
/// Height of the generated buffer.
|
|
height: i64, 768,
|
|
/// Random seed.
|
|
seed: f64, 0.0,
|
|
/// High values give more variation in details.
|
|
turbulence: f64, 1.0,
|
|
/// Width of the generated buffer.
|
|
width: i64, 1024,
|
|
/// X coordinate start of the generated buffer.
|
|
x: i64, 0,
|
|
/// Y coordinate start of the generated buffer.
|
|
y: i64, 0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: SimplexNoise,
|
|
gegl_name: "simplex-noise",
|
|
append_crop: true,
|
|
values: (
|
|
/// The number of noise octaves.
|
|
iterations: i64, 1,
|
|
/// The scale of the noise function.
|
|
scale: f64, 1.0,
|
|
/// The random seed for the noise function.
|
|
seed: f64, 1.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Softglow,
|
|
gegl_name: "softglow",
|
|
append_crop: false,
|
|
values: (
|
|
/// Brightness intensity.
|
|
brightness: f64, 0.3,
|
|
/// Glow radius.
|
|
glow_radius: f64, 10.0,
|
|
/// Sharpness of the highlights.
|
|
sharpness: f64, 0.85,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: StereographicProjection,
|
|
gegl_name: "stereographic-projection",
|
|
append_crop: false,
|
|
values: (
|
|
/// Output/rendering height in pixels, -1 for input height.
|
|
height: i64, -1,
|
|
/// Do the inverse mapping.
|
|
inverse: bool, false,
|
|
/// Horizontal camera panning.
|
|
pan: f64, 0.0,
|
|
/// Image resampling method to use.
|
|
sampler_type: StereographicProjectionSamplerType, StereographicProjectionSamplerType::Nearest,
|
|
/// Spin angle around camera axis.
|
|
spin: f64, 0.,
|
|
/// Vertical camera panning.
|
|
tilt: f64, 90.,
|
|
/// Output/rendering width in pixels, -1 for input width.
|
|
width: i64, -1,
|
|
/// Zoom level.
|
|
zoom: f64, 100.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: TileGlass,
|
|
gegl_name: "tile-glass",
|
|
append_crop: false,
|
|
values: (
|
|
/// Tile height.
|
|
tile_height: i64, 25,
|
|
/// Tile width.
|
|
tile_width: i64, 25,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: TileSeamless,
|
|
gegl_name: "tile-seamless",
|
|
append_crop: false,
|
|
values: (,),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Waterpixels,
|
|
gegl_name: "waterpixels",
|
|
append_crop: false,
|
|
values: (
|
|
/// How to fill superpixels.
|
|
fill: WaterpixelsFill, WaterpixelsFill::Average,
|
|
/// Spatial regularization, trade-off between superpixel regularity and
|
|
/// adherence to object boundaries.
|
|
regularization: i64, 0,
|
|
/// Superpixels size.
|
|
size: i64, 32,
|
|
/// Gradient smoothness.
|
|
smoothness: f64, 1.0,
|
|
),
|
|
);
|
|
|
|
gegl_operation!(
|
|
struct_name: Waves,
|
|
gegl_name: "waves",
|
|
append_crop: true,
|
|
values: (
|
|
/// Amplitude of the wave ripples.
|
|
amplitude: f64, 25.0,
|
|
/// Aspect ratio.
|
|
aspect: f64, 1.0,
|
|
/// Limit deformation in the image area.
|
|
clamp: bool, false,
|
|
/// Period/wavelength of the ripples.
|
|
period: f64, 100.0,
|
|
/// Phase shift of the waves.
|
|
phi: f64, 0.0,
|
|
/// Mathematical method for reconstructing pixel values.
|
|
sampler_type: WavesSamplerType, WavesSamplerType::Cubic,
|
|
/// Center X coordinate to start the waves from.
|
|
x: f64, 0.5,
|
|
/// Center Y coordinate to start the waves from.
|
|
y: f64, 0.5,
|
|
),
|
|
);
|