Enum FilterVariant

Source

pub enum FilterVariant {
Show 64 variants    Average,
    Blur,
    BlurMore,
    BoxBlur(RadiusFilter),
    GaussianBlur(RadiusFilter),
    MotionBlur {
        angle: f64,
        distance: UnitsValue,
    },
    RadialBlur {
        amount: f64,
        method: RadialBlurMethod,
        quality: RadialBlurQuality,
    },
    ShapeBlur {
        radius: UnitsValue,
        custom_shape: NamedId,
    },
    SmartBlur {
        radius: f64,
        threshold: f64,
        quality: LowMediumHigh,
        mode: SmartBlurMode,
    },
    SurfaceBlur {
        radius: UnitsValue,
        threshold: f64,
    },
    Displace {
        horizontal_scale: f64,
        vertical_scale: f64,
        displacement_map: DisplacementMap,
        undefined_areas: WrapOrRepeat,
        displacement_file: DisplacementFile,
    },
    Pinch {
        amount: f64,
    },
    PolarCoordinates {
        conversion: PolarConversion,
    },
    Ripple {
        amount: f64,
        size: SmallMediumLarge,
    },
    Shear {
        shear_points: Vec<PointF>,
        shear_start: f64,
        shear_end: f64,
        undefined_areas: WrapOrRepeat,
    },
    Spherize {
        amount: f64,
        mode: SpherizeMode,
    },
    Twirl {
        angle: f64,
    },
    Wave {
        number_of_generators: f64,
        wave_type: WaveType,
        wavelength: MinMax,
        amplitude: MinMax,
        scale: PointF,
        random_seed: f64,
        undefined_areas: WrapOrRepeat,
    },
    ZigZag {
        amount: f64,
        ridges: f64,
        style: ZigZagStyle,
    },
    AddNoise {
        amount: f64,
        distribution: NoiseDistribution,
        monochromatic: bool,
        random_seed: f64,
    },
    Despeckle,
    DustAndScratches {
        radius: f64,
        threshold: f64,
    },
    Median(RadiusFilter),
    ReduceNoise {
        preset: String,
        remove_jpeg_artifact: bool,
        reduce_color_noise: f64,
        sharpen_details: f64,
        channel_denoise: Vec<ChannelDenoise>,
    },
    ColorHalftone {
        radius: f64,
        angle1: f64,
        angle2: f64,
        angle3: f64,
        angle4: f64,
    },
    Crystallize {
        cell_size: f64,
        random_seed: f64,
    },
    Facet,
    Fragment,
    Mezzotint {
        mezzotint_type: MezzotintType,
        random_seed: f64,
    },
    Mosaic {
        cell_size: UnitsValue,
    },
    Pointillize {
        cell_size: f64,
        random_seed: f64,
    },
    Clouds {
        random_seed: f64,
    },
    DifferenceClouds {
        random_seed: f64,
    },
    Fibers {
        variance: f64,
        strength: f64,
        random_seed: f64,
    },
    LensFlare {
        brightness: f64,
        position: PointF,
        lens_type: LensType,
    },
    Sharpen,
    SharpenEdges,
    SharpenMore,
    SmartSharpen {
        amount: f64,
        radius: UnitsValue,
        threshold: f64,
        angle: f64,
        more_accurate: bool,
        blur: SmartSharpenBlur,
        preset: String,
        shadow: SmartSharpenTone,
        highlight: SmartSharpenTone,
    },
    UnsharpMask {
        amount: f64,
        radius: UnitsValue,
        threshold: f64,
    },
    Diffuse {
        mode: DiffuseMode,
        random_seed: f64,
    },
    Emboss {
        angle: f64,
        height: f64,
        amount: f64,
    },
    Extrude {
        extrude_type: ExtrudeType,
        size: f64,
        depth: f64,
        depth_mode: ExtrudeDepthMode,
        random_seed: f64,
        solid_front_faces: bool,
        mask_incomplete_blocks: bool,
    },
    FindEdges,
    Solarize,
    Tiles {
        number_of_tiles: f64,
        maximum_offset: f64,
        fill_empty_area_with: TilesFill,
        random_seed: f64,
    },
    TraceContour {
        level: f64,
        edge: LowerUpper,
    },
    Wind {
        method: WindMethod,
        direction: LeftRight,
    },
    DeInterlace {
        eliminate: DeInterlaceEliminate,
        new_fields_by: DeInterlaceNewFields,
    },
    NtscColors,
    Custom {
        scale: f64,
        offset: f64,
        matrix: Vec<f64>,
    },
    HighPass(RadiusFilter),
    Maximum(RadiusFilter),
    Minimum(RadiusFilter),
    Offset {
        horizontal: f64,
        vertical: f64,
        undefined_areas: OffsetUndefinedAreas,
    },
    Puppet {
        rigid_type: bool,
        bounds: Vec<PointF>,
        puppet_shape_list: Vec<PuppetShape>,
    },
    OilPaintPlugin {
        name: String,
        gpu: bool,
        lighting: bool,
        parameters: Vec<NamedValue>,
    },
    HsbHsl {
        input_mode: RgbHsbHsl,
        row_order: RgbHsbHsl,
    },
    OilPaint {
        lighting_on: bool,
        stylization: f64,
        cleanliness: f64,
        brush_scale: f64,
        micro_brush: f64,
        light_direction: f64,
        specularity: f64,
    },
    Liquify {
        liquify_mesh: Vec<u8>,
    },
    PerspectiveWarp {
        quads: Vec<Vec<f64>>,
        vertices: Vec<UnitsPoint>,
        warped_vertices: Vec<UnitsPoint>,
    },
    Curves {
        preset_kind: CurvesPresetKind,
        adjustments: Option<Vec<CurvesFilterAdjustment>>,
    },
    Invert,
    BrightnessContrast {
        brightness: f64,
        contrast: f64,
        use_legacy: bool,
    },
}