Struct MorphShape

pub struct MorphShape { /* private fields */ }

Expand description

A morphing filled shape view.

Implementations§

Sets explicit animation configuration.

Sets the cycle duration (keeps other animation options unchanged).

Sets easing (keeps other animation options unchanged).

Enables/disables repeating.

Enables/disables autoreverse for repeating animations.

Overrides animated progress with an explicit reactive progress signal [0, 1].

When set, this takes precedence over the time-based animation config.

Trait Implementations§

Returns a duplicate of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Build this view and return the content. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Apply a Effect to this view. Read more

Apply a blur filter. Read more

Apply a brightness filter.

Apply an exposure filter in photographic stops.

Apply a gamma adjustment filter.

Apply a contrast filter.

Apply a saturation filter.

Apply a vibrance filter.

Apply a grayscale filter.

Apply a hue rotation filter.

Apply an invert filter.

Apply a Sobel edge-detection filter (3x3, gradient magnitude).

Apply a Prewitt edge-detection filter (3x3, uniform-weight kernels).

Apply a 3x3 per-channel median filter for salt-and-pepper denoising.

Apply a 3x3 convolution filter with a caller-supplied kernel (row-major, top-left to bottom-right).

Apply a 5x5 convolution filter with a caller-supplied 25-element kernel (row-major).

Apply a 3x3 morphological erosion (per-channel minimum).

Apply a 3x3 morphological dilation (per-channel maximum).

Apply a 3x3 morphological gradient (per-channel max minus min).

Apply the monochrome photo preset.

Apply the noir photo preset.

Apply the chrome photo preset.

Apply the instant photo preset.

Apply the fade photo preset.

Apply the process photo preset.

Apply the tonal photo preset.

Apply the transfer photo preset.

Apply a sepia filter.

Apply a sharpen filter.

Apply a temperature/tint white-balance adjustment.

Recover highlights while lifting shadows.

Apply directional motion blur.

Apply a vignette filter.

Adjust color balance using an explicit white point triplet.

Apply radial zoom blur around a focal point.

Apply a gaussian blur filter.

Apply a 3x4 color matrix transform.

Apply bloom around bright regions.

Apply gloom around bright regions.

Apply an unsharp mask.

Apply bump distortion around a center.

Apply pinch distortion around a center.

Apply twirl distortion around a center.

Apply vortex distortion around a center.

Warp a source quadrilateral into the output rectangle.

Correct a perspective-skewed quadrilateral back to a rectangle.

Apply a pixellate effect.

Apply a crystallize effect.

Apply an edge-work effect.

Apply a dot halftone effect.

Apply a line halftone effect.

Apply a kaleidoscope effect.

Apply mirrored tiling.

Blend the current content with an auxiliary image.

Apply masked blur using an auxiliary mask image.

Transition to another image.

Transition to another image with a directional swipe.

Transition to another image from a radial reveal center.

Transition to another image with a zooming blend.

Transition to another image driven by a displacement map.

Warp with an auxiliary displacement map.

Apply guide-image-aware smoothing.

Apply depth-aware blur using a depth map.

Temporal denoise/stabilize using history and motion maps.

Replace background using matte and background images.

Apply a 3D LUT color transform encoded as a 2D strip (size*size x size).

Apply a simple master tone curve.

Returns the argument unchanged.

A constant of the type witness

Wraps the value in a UseId with the provided identification function.

Wraps the value in a SelfId, making the value serve as its own identifier.

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

The resulting View type after conversion.

Converts the implementing type into a View. Read more

The alignment of pointer.

The type for initializers.

Initializes a with the given initializer. Read more

Dereferences the given pointer. Read more

Mutably dereferences the given pointer. Read more

Drops the object pointed to by the given pointer. Read more

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

MorphShape

Struct MorphShape Copy item path

Implementations§

impl MorphShape

pub const fn animation(self, animation: MorphAnimation) -> Self

pub const fn duration(self, duration: Duration) -> Self

pub const fn easing(self, easing: EasingCurve) -> Self

pub const fn repeat(self, repeat: bool) -> Self

pub const fn autoreverse(self, autoreverse: bool) -> Self

pub fn progress(self, progress: impl IntoComputed<f32>) -> Self

Trait Implementations§

impl Clone for MorphShape

fn clone(&self) -> Self

fn clone_from(&mut self, source: &Self)

impl Debug for MorphShape

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl View for MorphShape

fn body(self, env: &Environment) -> impl View

Auto Trait Implementations§

impl !RefUnwindSafe for MorphShape

impl !Send for MorphShape

impl !Sync for MorphShape

impl !UnwindSafe for MorphShape

impl Freeze for MorphShape

impl Unpin for MorphShape

impl UnsafeUnpin for MorphShape

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DTwhere ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DTwhere ST: ?Sized, DT: ?Sized,

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

impl<V> FilterViewExt for Vwhere V: View,

fn filter<F>(self, filter: F) -> Filtered<Self, F>where F: Effect,

fn blur<T>( self, radius: T, ) -> Filtered<Self, FilterAdapter<Blur<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn brightness<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Brightness<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn exposure<T>( self, ev: T, ) -> Filtered<Self, FilterAdapter<Exposure<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn gamma<T>( self, gamma: T, ) -> Filtered<Self, FilterAdapter<Gamma<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn contrast<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Contrast<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn saturation<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Saturation<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn vibrance<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Vibrance<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn grayscale<T>( self, intensity: T, ) -> Filtered<Self, FilterAdapter<Grayscale<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn hue_rotation<T>( self, angle: T, ) -> Filtered<Self, FilterAdapter<HueRotation<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn invert(self) -> Filtered<Self, FilterAdapter<Invert>>

fn sobel(self) -> Filtered<Self, FilterAdapter<Sobel>>

fn prewitt(self) -> Filtered<Self, FilterAdapter<Prewitt>>

fn median3x3(self) -> Filtered<Self, FilterAdapter<Median3x3>>

fn convolution3x3<P>( self, kernel: [P; 9], ) -> Filtered<Self, FilterAdapter<Convolution3x3<Reactive<Computed<f32>>>>>where P: IntoSignalF32 + Copy,

fn convolution5x5<P>( self, kernel: [P; 25], ) -> Filtered<Self, FilterAdapter<Convolution5x5<Reactive<Computed<f32>>>>>where P: IntoSignalF32 + Copy,

fn morphology_min(self) -> Filtered<Self, FilterAdapter<MorphologyMin>>

fn morphology_max(self) -> Filtered<Self, FilterAdapter<MorphologyMax>>

fn morphology_gradient( self, ) -> Filtered<Self, FilterAdapter<MorphologyGradient>>

fn photo_effect_mono(self) -> Filtered<Self, FilterAdapter<PhotoEffectMono>>

fn photo_effect_noir(self) -> Filtered<Self, FilterAdapter<PhotoEffectNoir>>

fn photo_effect_chrome(self) -> Filtered<Self, FilterAdapter<PhotoEffectChrome>>

fn photo_effect_instant( self, ) -> Filtered<Self, FilterAdapter<PhotoEffectInstant>>

fn photo_effect_fade(self) -> Filtered<Self, FilterAdapter<PhotoEffectFade>>

fn photo_effect_process( self, ) -> Filtered<Self, FilterAdapter<PhotoEffectProcess>>

fn photo_effect_tonal(self) -> Filtered<Self, FilterAdapter<PhotoEffectTonal>>

fn photo_effect_transfer( self, ) -> Filtered<Self, FilterAdapter<PhotoEffectTransfer>>

fn sepia<T>( self, intensity: T, ) -> Filtered<Self, FilterAdapter<Sepia<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn sharpen<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Sharpen<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn temperature_tint<T, U>( self, temperature: T, tint: U, ) -> Filtered<Self, FilterAdapter<TemperatureTint<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>where T: IntoSignalF32, U: IntoSignalF32,

fn highlights_shadows<H, S>( self, highlights: H, shadows: S, ) -> Filtered<Self, FilterAdapter<HighlightsShadows<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>where H: IntoSignalF32, S: IntoSignalF32,

fn motion_blur<R, A>( self, radius: R, angle: A, ) -> Filtered<Self, FilterAdapter<MotionBlur<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>where R: IntoSignalF32, A: IntoSignalF32,

fn vignette<R, S>( self, radius: R, softness: S, ) -> Filtered<Self, FilterAdapter<Vignette<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>where R: IntoSignalF32, S: IntoSignalF32,

fn white_point<R, G, B>( self, red: R, green: G, blue: B, ) -> Filtered<Self, FilterAdapter<WhitePoint<Reactive<Computed<f32>>, Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>where R: IntoSignalF32, G: IntoSignalF32, B: IntoSignalF32,

fn zoom_blur<A, X, Y>( self, amount: A, center_x: X, center_y: Y, ) -> Filtered<Self, FilterAdapter<ZoomBlur<Reactive<Computed<f32>>, Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>where A: IntoSignalF32, X: IntoSignalF32, Y: IntoSignalF32,

fn gaussian_blur<T>( self, sigma: T, ) -> Filtered<Self, FilterAdapter<GaussianBlur<Reactive<Computed<f32>>>>>where T: IntoSignalF32,

fn color_matrix( self, matrix: [[f32; 4]; 3], ) -> Filtered<Self, FilterAdapter<ColorMatrix<f32>>>

fn bloom<T, U, V>( self, radius: T, intensity: U, threshold: V, ) -> Filtered<Self, FilterAdapter<Bloom<Reactive<Computed<f32>>>>>where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32,

fn gloom<T, U, V>( self, radius: T, intensity: U, threshold: V, ) -> Filtered<Self, FilterAdapter<Gloom<Reactive<Computed<f32>>>>>where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32,

fn unsharp_mask<T, U>( self, radius: T, amount: U, ) -> Filtered<Self, FilterAdapter<UnsharpMask<Reactive<Computed<f32>>>>>where T: IntoSignalF32, U: IntoSignalF32,

Struct MorphShape

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<V> FilterViewExt for V
where V: View,

fn filter<F>(self, filter: F) -> Filtered<Self, F>
where F: Effect,

fn blur<T>( self, radius: T, ) -> Filtered<Self, FilterAdapter<Blur<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn brightness<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Brightness<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn exposure<T>( self, ev: T, ) -> Filtered<Self, FilterAdapter<Exposure<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn gamma<T>( self, gamma: T, ) -> Filtered<Self, FilterAdapter<Gamma<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn contrast<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Contrast<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn saturation<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Saturation<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn vibrance<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Vibrance<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn grayscale<T>( self, intensity: T, ) -> Filtered<Self, FilterAdapter<Grayscale<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn hue_rotation<T>( self, angle: T, ) -> Filtered<Self, FilterAdapter<HueRotation<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn convolution3x3<P>( self, kernel: [P; 9], ) -> Filtered<Self, FilterAdapter<Convolution3x3<Reactive<Computed<f32>>>>>
where P: IntoSignalF32 + Copy,

fn convolution5x5<P>( self, kernel: [P; 25], ) -> Filtered<Self, FilterAdapter<Convolution5x5<Reactive<Computed<f32>>>>>
where P: IntoSignalF32 + Copy,

fn sepia<T>( self, intensity: T, ) -> Filtered<Self, FilterAdapter<Sepia<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn sharpen<T>( self, amount: T, ) -> Filtered<Self, FilterAdapter<Sharpen<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn temperature_tint<T, U>( self, temperature: T, tint: U, ) -> Filtered<Self, FilterAdapter<TemperatureTint<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn highlights_shadows<H, S>( self, highlights: H, shadows: S, ) -> Filtered<Self, FilterAdapter<HighlightsShadows<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>
where H: IntoSignalF32, S: IntoSignalF32,

fn motion_blur<R, A>( self, radius: R, angle: A, ) -> Filtered<Self, FilterAdapter<MotionBlur<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>
where R: IntoSignalF32, A: IntoSignalF32,

fn vignette<R, S>( self, radius: R, softness: S, ) -> Filtered<Self, FilterAdapter<Vignette<Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>
where R: IntoSignalF32, S: IntoSignalF32,

fn white_point<R, G, B>( self, red: R, green: G, blue: B, ) -> Filtered<Self, FilterAdapter<WhitePoint<Reactive<Computed<f32>>, Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>
where R: IntoSignalF32, G: IntoSignalF32, B: IntoSignalF32,

fn zoom_blur<A, X, Y>( self, amount: A, center_x: X, center_y: Y, ) -> Filtered<Self, FilterAdapter<ZoomBlur<Reactive<Computed<f32>>, Reactive<Computed<f32>>, Reactive<Computed<f32>>>>>
where A: IntoSignalF32, X: IntoSignalF32, Y: IntoSignalF32,

fn gaussian_blur<T>( self, sigma: T, ) -> Filtered<Self, FilterAdapter<GaussianBlur<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn bloom<T, U, V>( self, radius: T, intensity: U, threshold: V, ) -> Filtered<Self, FilterAdapter<Bloom<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32,

fn gloom<T, U, V>( self, radius: T, intensity: U, threshold: V, ) -> Filtered<Self, FilterAdapter<Gloom<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32,

fn unsharp_mask<T, U>( self, radius: T, amount: U, ) -> Filtered<Self, FilterAdapter<UnsharpMask<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn bump_distortion<T, U, V, W>( self, center_x: T, center_y: U, radius: V, scale: W, ) -> Filtered<Self, FilterAdapter<BumpDistortion<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn pinch_distortion<T, U, V, W>( self, center_x: T, center_y: U, radius: V, scale: W, ) -> Filtered<Self, FilterAdapter<PinchDistortion<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn twirl_distortion<T, U, V, W>( self, center_x: T, center_y: U, radius: V, angle: W, ) -> Filtered<Self, FilterAdapter<TwirlDistortion<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn vortex_distortion<T, U, V, W>( self, center_x: T, center_y: U, radius: V, angle: W, ) -> Filtered<Self, FilterAdapter<VortexDistortion<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn pixellate<T>( self, size: T, ) -> Filtered<Self, FilterAdapter<Pixellate<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn crystallize<T>( self, size: T, ) -> Filtered<Self, FilterAdapter<Crystallize<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn edge_work<T, U>( self, radius: T, amount: U, ) -> Filtered<Self, FilterAdapter<EdgeWork<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn dot_halftone<T, U, V, W>( self, scale: T, angle: U, center_x: V, center_y: W, ) -> Filtered<Self, FilterAdapter<DotHalftone<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn line_halftone<T, U, V, W>( self, scale: T, angle: U, center_x: V, center_y: W, ) -> Filtered<Self, FilterAdapter<LineHalftone<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn kaleidoscope<T, U, V, W>( self, segments: T, angle: U, center_x: V, center_y: W, ) -> Filtered<Self, FilterAdapter<Kaleidoscope<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, V: IntoSignalF32, W: IntoSignalF32,

fn mirror_tile<T, U>( self, repeat_x: T, repeat_y: U, ) -> Filtered<Self, FilterAdapter<MirrorTile<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn blend_with_image<T>( self, image: FilterImage, amount: T, mode: BlendMode, ) -> Filtered<Self, MultiInputFilter<BlendWithImage<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn masked_blur<T, U>( self, mask: FilterImage, radius: T, strength: U, ) -> Filtered<Self, MultiInputFilter<MaskedBlur<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn transition_to_image<T, U>( self, target: FilterImage, progress: T, softness: U, ) -> Filtered<Self, MultiInputFilter<TransitionToImage<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn swipe_transition_to_image<T, U>( self, target: FilterImage, progress: T, softness: U, direction: TransitionDirection, ) -> Filtered<Self, MultiInputFilter<SwipeTransitionToImage<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn radial_transition_to_image<T, U>( self, target: FilterImage, progress: T, softness: U, center_x: f32, center_y: f32, ) -> Filtered<Self, MultiInputFilter<RadialTransitionToImage<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn zoom_transition_to_image<T, U>( self, target: FilterImage, progress: T, amount: U, center_x: f32, center_y: f32, ) -> Filtered<Self, MultiInputFilter<ZoomTransitionToImage<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn displacement_transition_to_image<T, U>( self, target: FilterImage, map: FilterImage, progress: T, scale: U, ) -> Filtered<Self, MultiInputFilter<DisplacementTransitionToImage<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn displacement_warp<T, U>( self, map: FilterImage, scale_x: T, scale_y: U, ) -> Filtered<Self, MultiInputFilter<DisplacementWarp<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32,

fn guided_smooth<T, U, W>( self, guide: FilterImage, radius: T, range_sigma: U, amount: W, ) -> Filtered<Self, MultiInputFilter<GuidedSmooth<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, W: IntoSignalF32,

fn depth_aware_blur<T, U, W>( self, depth: FilterImage, focus_depth: T, aperture: U, max_radius: W, ) -> Filtered<Self, MultiInputFilter<DepthAwareBlur<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, W: IntoSignalF32,

fn temporal_denoise<T>( self, history: FilterImage, motion: FilterImage, history_weight: T, ) -> Filtered<Self, MultiInputFilter<TemporalDenoise<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn replace_background<T>( self, matte: FilterImage, background: FilterImage, edge_softness: T, ) -> Filtered<Self, MultiInputFilter<BackgroundReplace<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn lut_color_grade<T>( self, lut: LutImage, intensity: T, ) -> Filtered<Self, MultiInputFilter<LutColorGrade<Reactive<Computed<f32>>>>>
where T: IntoSignalF32,

fn tone_curve<T, U, W, X, Y>( self, shadows: T, midtones: U, highlights: W, gamma: X, amount: Y, ) -> Filtered<Self, MultiInputFilter<ToneCurve<Reactive<Computed<f32>>>>>
where T: IntoSignalF32, U: IntoSignalF32, W: IntoSignalF32, X: IntoSignalF32, Y: IntoSignalF32,

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

fn use_id<F, Id>(self, f: F) -> UseId<Self, F>
where F: Fn(&Self) -> Id, Id: Ord + Hash,

impl<T> Identity for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

impl<V> IntoView for V
where V: View,

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

impl<T, S> SimdFrom<T, S> for T
where S: Simd,

impl<F, T, S> SimdInto<T, S> for F
where T: SimdFrom<F, S>, S: Simd,

impl<T> ToOwned for T
where T: Clone,