How to edit the UIBlurEffect intensity?

Question

I don't want my background image to be too blury. Isn't there a property to adjust the blur intensity?

let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.Light)
blurEffect.???
let effectView = UIVisualEffectView(effect: blurEffect)
effectView.frame = backgroundAlbumCover.bounds
backgroundAlbumCover.addSubview(effectView)

Answer 1

You can do that in super elegant way with animator

(reducing UIVisualEffectView alpha will not affect blur intensity, so we must use animator)

Usage as simple as:

let blurEffectView = BlurEffectView()
view.addSubview(blurEffectView)

BlurEffectView realisation:

class BlurEffectView: UIVisualEffectView {
    
    var animator = UIViewPropertyAnimator(duration: 1, curve: .linear)
    
    override func didMoveToSuperview() {
        guard let superview = superview else { return }
        backgroundColor = .clear
        frame = superview.bounds //Or setup constraints instead
        setupBlur()
    }
    
    private func setupBlur() {
        animator.stopAnimation(true)
        effect = nil

        animator.addAnimations { [weak self] in
            self?.effect = UIBlurEffect(style: .dark)
        }
        animator.fractionComplete = 0.1   //This is your blur intensity in range 0 - 1
    }
    
    deinit {
        animator.stopAnimation(true)
    }
}

Answer 2

Adjusting the blur itself is not possible... But, you can adjust how visible the blur view is. This can be done in a number of ways, only three of which I can think of at the moment:

1st Option: Adjust the alpha of your UIVisualEffectView instance e.g:

effectView.alpha = 0.4f;

2nd Option: Add a UIView instance to effectView at Index 0 and adjust the alpha of this UIView instance. e.g:

UIView *blurDilutionView = [[UIView alloc] initWithFrame: effectView.frame];
blurDilutionView.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent: 0.5];
blurDilutionView.autoresizingMask = UIViewAutoresizingFlexibleTopMargin|UIViewAutoresizingFlexibleBottomMargin|UIViewAutoresizingFlexibleWidth|UIViewAutoresizingFlexibleHeight;//if not using AutoLayout
[effectView insertSubview:blurDilutionView atIndex:0];

3rd Option: use multiple UIVisualEffectView instances (I have not tried this yet, more of an idea). Apply an alpha of 0.1f on each. The more UIVisualEffectView views you have the more blurry the overall look. Once again, I have not tried this option yet!

Update: As Axeva mentioned in the comments, Apple advises against adjusting the alpha to change the blur. So use these suggestions at your own potential peril.

Answer 3

Once I ran into a problem to create a blur effect that is darker than .light and lighter than .dark UIBlurEffect style.

To achieve that, put a view on the back with the color and alpha you need:

    let pictureImageView = // Image that you need to blur
    let backView = UIView(frame: pictureImageView.bounds)
    backView.backgroundColor = UIColor(red: 100/255, green: 100/255, blue: 100/255, alpha: 0.3)
    pictureImageView.addSubview(backView)

    let blurEffect = UIBlurEffect(style: .light)
    let blurEffectView = UIVisualEffectView(effect: blurEffect)
    blurEffectView.frame = pictureImageView.bounds
    pictureImageView.addSubview(blurEffectView)

How the result looks like:

For more details, check out this article.

UPDATE: apparently there is another nice (maybe even nicer) way to implement the Blur using CIFilter(name: "CIGaussianBlur"). It allows the make “opacity” and blur’s strengths much lower than UIBlurEffect.

Answer 4

Use Private API if you want. Tested on iOS 13.7, 14.8, 15.5, 16.0. Does not work with Mac Catalyst.

Sample

• UIVisualEffectView+Intensity.h

#import <UIKit/UIKit.h>

NS_ASSUME_NONNULL_BEGIN

@interface UIVisualEffectView (Intensity)
@property (nonatomic) CGFloat intensity;
@end

NS_ASSUME_NONNULL_END

• UIVisualEffectView+Intensity.m

#import "UIVisualEffectView+Intensity.h"
#import <objc/message.h>

@interface UIVisualEffectView (Intensity)
@property (readonly) id backgroundHost; // _UIVisualEffectHost
@property (readonly) __kindof UIView *backdropView; // _UIVisualEffectBackdropView
@end

@implementation UIVisualEffectView (Intensity)

- (id)backgroundHost {
    id backgroundHost = ((id (*)(id, SEL))objc_msgSend)(self, NSSelectorFromString(@"_backgroundHost")); // _UIVisualEffectHost
    return backgroundHost;
}

- (__kindof UIView * _Nullable)backdropView {
    __kindof UIView *backdropView = ((__kindof UIView * (*)(id, SEL))objc_msgSend)(self.backgroundHost, NSSelectorFromString(@"contentView")); // _UIVisualEffectBackdropView
    return backdropView;
}

- (CGFloat)intensity {
    __kindof UIView *backdropView = self.backdropView; // _UIVisualEffectBackdropView
    __kindof CALayer *backdropLayer = ((__kindof CALayer * (*)(id, SEL))objc_msgSend)(backdropView, NSSelectorFromString(@"backdropLayer")); // UICABackdropLayer
    
    NSArray *filters = backdropLayer.filters;
    id _Nullable __block gaussianBlur = nil; // CAFilter
    
    [filters enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        if (![obj respondsToSelector:NSSelectorFromString(@"type")]) return;
        
        NSString *type = ((NSString * (*)(id, SEL))objc_msgSend)(obj, NSSelectorFromString(@"type"));
        
        if (![type isKindOfClass:[NSString class]]) return;
        
        if ([type isEqualToString:@"gaussianBlur"]) {
            gaussianBlur = obj;
            *stop = YES;
        }
    }];
    
    if (gaussianBlur == nil) return 0.0f;
    
    NSNumber * _Nullable inputRadius = [gaussianBlur valueForKeyPath:@"inputRadius"];
    
    if ((inputRadius == nil) || (![inputRadius isKindOfClass:[NSNumber class]])) return 0.0f;
    
    return [inputRadius floatValue];
}

- (void)setIntensity:(CGFloat)intensity {
    id descriptor = ((id (*)(id, SEL, id, BOOL))objc_msgSend)(self, NSSelectorFromString(@"_effectDescriptorForEffects:usage:"), @[self.effect], YES); // _UIVisualEffectDescriptor
    
    NSArray *filterEntries = ((NSArray * (*)(id, SEL))objc_msgSend)(descriptor, NSSelectorFromString(@"filterEntries")); // NSArray<_UIVisualEffectFilterEntry *>
    
    id _Nullable __block gaussianBlur = nil; // _UIVisualEffectFilterEntry
    
    [filterEntries enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        NSString *filterType = ((NSString * (*)(id, SEL))objc_msgSend)(obj, NSSelectorFromString(@"filterType"));
        
        if ([filterType isEqualToString:@"gaussianBlur"]) {
            gaussianBlur = obj;
            *stop = YES;
        }
    }];
    
    if (gaussianBlur == nil) return;
    
    NSMutableDictionary *requestedValues = [((NSDictionary * (*)(id, SEL))objc_msgSend)(gaussianBlur, NSSelectorFromString(@"requestedValues")) mutableCopy];

    if (![requestedValues.allKeys containsObject:@"inputRadius"]) {
        NSLog(@"Not supported effect.");
        return;
    }

    requestedValues[@"inputRadius"] = [NSNumber numberWithFloat:intensity];

    ((void (*)(id, SEL, NSDictionary *))objc_msgSend)(gaussianBlur, NSSelectorFromString(@"setRequestedValues:"), requestedValues);
    
    ((void (*)(id, SEL, id))objc_msgSend)(self.backgroundHost, NSSelectorFromString(@"setCurrentEffectDescriptor:"), descriptor);
    
    ((void (*)(id, SEL))objc_msgSend)(self.backdropView, NSSelectorFromString(@"applyRequestedFilterEffects"));
}

@end

• Usage

let firstBlurView: UIVisualEffectView = .init(effect: UIBlurEffect(style: .dark))

// setter
firstBlurView.intensity = 7

// getter
print(firstBlurView.intensity) // 7.0

Answer 5

UIBlurEffect doesn't provide such a property. If you want another intensity, you will have to make a BlurEffect by yourself.

Answer 6

Here is the BlurEffectView class with public intensity setter as well as with conformance to Apple's UIView.animation functions (you can animate intensity by UIKit's animations)

BlurEffectView.swift

import UIKit

public class BlurEffectView: UIView {

public override class var layerClass: AnyClass {
    return BlurIntensityLayer.self
}

@objc
@IBInspectable
public dynamic var intensity: CGFloat {
    set { self.blurIntensityLayer.intensity = newValue }
    get { return self.blurIntensityLayer.intensity }
}
@IBInspectable
public var effect = UIBlurEffect(style: .dark) {
    didSet {
        self.setupPropertyAnimator()
    }
}
private let visualEffectView = UIVisualEffectView(effect: nil)
private var propertyAnimator: UIViewPropertyAnimator!
private var blurIntensityLayer: BlurIntensityLayer {
    return self.layer as! BlurIntensityLayer
}

public override init(frame: CGRect) {
    super.init(frame: frame)
    self.setupView()
}

public required init?(coder: NSCoder) {
    super.init(coder: coder)
    self.setupView()
}

deinit {
    self.propertyAnimator.stopAnimation(true)
}

private func setupPropertyAnimator() {
    self.propertyAnimator?.stopAnimation(true)
    self.propertyAnimator = UIViewPropertyAnimator(duration: 1, curve: .linear)
    self.propertyAnimator.addAnimations { [weak self] in
        self?.visualEffectView.effect = self?.effect
    }
    self.propertyAnimator.pausesOnCompletion = true
}
  
private func setupView() {
    self.backgroundColor = .clear
    self.isUserInteractionEnabled = false
    
    self.addSubview(self.visualEffectView)
    self.visualEffectView.fill(view: self)
    self.setupPropertyAnimator()
}

public override func display(_ layer: CALayer) {
    guard let presentationLayer = layer.presentation() as? BlurIntensityLayer else {
        return
    }
    let clampedIntensity = max(0.0, min(1.0, presentationLayer.intensity))
    self.propertyAnimator.fractionComplete = clampedIntensity
}
}

BlurIntensityLayer.swift

import QuartzCore

class BlurIntensityLayer: CALayer {

@NSManaged var intensity: CGFloat

override init(layer: Any) {
    super.init(layer: layer)
    
    if let layer = layer as? BlurIntensityLayer {
        self.intensity = layer.intensity
    }
}

override init() {
    super.init()
}

required init?(coder aDecoder: NSCoder) {
    super.init(coder: aDecoder)
}

override class func needsDisplay(forKey key: String) -> Bool {
    key == #keyPath(intensity) ? true : super.needsDisplay(forKey: key)
}

override func action(forKey event: String) -> CAAction? {
    guard event == #keyPath(intensity) else {
        return super.action(forKey: event)
    }
    
    let animation = CABasicAnimation(keyPath: event)
    animation.toValue = nil
    animation.fromValue = (self.presentation() ?? self).intensity
    return animation
}
}