Ajout d'un effet de flou à l'arrière-plan en Swift

Je configure une image d'arrière-plan pour afficher le contrôleur. Mais aussi je veux ajouter un effet de flou à cet arrière-plan. Comment puis-je faire ceci?

Je mets l'arrière-plan avec le code suivant:

self.view.backgroundColor = UIColor(patternImage: UIImage(named: "testBg")!)

J'ai trouvé sur Internet pour une image floue comment puis-je implémenter cela dans mon arrière-plan?

var darkBlur = UIBlurEffect(style: UIBlurEffectStyle.Dark)
// 2
var blurView = UIVisualEffectView(effect: darkBlur)
blurView.frame = imageView.bounds
// 3
imageView.addSubview(blurView)

J'ai testé ce code et il fonctionne bien:

let blurEffect = UIBlurEffect(style: UIBlurEffect.Style.dark)
let blurEffectView = UIVisualEffectView(effect: blurEffect)
blurEffectView.frame = view.bounds
blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
view.addSubview(blurEffectView)

Pour Swift 3.0:

let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.dark)
let blurEffectView = UIVisualEffectView(effect: blurEffect)
blurEffectView.frame = view.bounds
blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
view.addSubview(blurEffectView)

Pour Swift 4.0:

let blurEffect = UIBlurEffect(style: UIBlurEffect.Style.dark)
let blurEffectView = UIVisualEffectView(effect: blurEffect)
blurEffectView.frame = view.bounds
blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
view.addSubview(blurEffectView)

Ici vous pouvez voir le résultat:

Ou vous pouvez utiliser cette bibliothèque pour cela:

https://github.com/FlexMonkey/Blurable

Vous pouvez créer une extension de UIImageView.

Swift 2.0

import Foundation
import UIKit

extension UIImageView
{
    func makeBlurImage(targetImageView:UIImageView?)
    {
        let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.Dark)
        let blurEffectView = UIVisualEffectView(effect: blurEffect)
        blurEffectView.frame = targetImageView!.bounds

        blurEffectView.autoresizingMask = [.FlexibleWidth, .FlexibleHeight] // for supporting device rotation
        targetImageView?.addSubview(blurEffectView)
    }
}

Usage:

override func viewDidLoad()
{
    super.viewDidLoad()

    let sampleImageView = UIImageView(frame: CGRectMake(0, 200, 300, 325))
    let sampleImage:UIImage = UIImage(named: "ic_120x120")!
    sampleImageView.image =  sampleImage

    //Convert To Blur Image Here
    sampleImageView.makeBlurImage(sampleImageView)

    self.view.addSubview(sampleImageView)
}

Extension Swift 3

import Foundation
import UIKit

extension UIImageView
{
    func addBlurEffect()
    {
        let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.light)
        let blurEffectView = UIVisualEffectView(effect: blurEffect)
        blurEffectView.frame = self.bounds

        blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight] // for supporting device rotation
        self.addSubview(blurEffectView)
    }
}

Usage:

yourImageView.addBlurEffect()

Addenda:

extension UIView {

  /// Remove UIBlurEffect from UIView
  func removeBlurEffect() {
    let blurredEffectViews = self.subviews.filter{$0 is UIVisualEffectView}
    blurredEffectViews.forEach{ blurView in
      blurView.removeFromSuperview()
    }
  }

@AlvinGeorge devrait simplement utiliser:

extension UIImageView{        
    func blurImage()
    {
        let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.Dark)
        let blurEffectView = UIVisualEffectView(effect: blurEffect)
        blurEffectView.frame = self.bounds

        blurEffectView.autoresizingMask = [.FlexibleWidth, .FlexibleHeight] // for supporting device rotation
        self.addSubview(blurEffectView)
    }
}

utilisation :

 blurredBackground.frame = self.view.bounds
 blurredBackground.blurImage()
 self.view.addSubview(self.blurredBackground)

Pour Swift 3 (iOS 10.0 et 8.0)

var darkBlur:UIBlurEffect = UIBlurEffect()

if #available(iOS 10.0, *) { //iOS 10.0 and above
    darkBlur = UIBlurEffect(style: UIBlurEffectStyle.prominent)//prominent,regular,extraLight, light, dark
} else { //iOS 8.0 and above
  darkBlur = UIBlurEffect(style: UIBlurEffectStyle.dark) //extraLight, light, dark
}
let blurView = UIVisualEffectView(effect: darkBlur)
blurView.frame = self.view.frame //your view that have any objects
blurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
view.addSubview(blurView)

Vous pouvez également utiliser CoreImage pour créer une image floue avec un effet sombre

1. Créer un instantané pour l'image

   func snapShotImage() -> UIImage {
       UIGraphicsBeginImageContext(self.frame.size)
       if let context = UIGraphicsGetCurrentContext() {
           self.layer.renderInContext(context)
           let image = UIGraphicsGetImageFromCurrentImageContext()
           UIGraphicsEndImageContext()
           return image
       }
   
       return UIImage()
   }

2. Appliquez les filtres CoreImage comme vous le souhaitez avec

   private func bluredImage(view:UIView, radius:CGFloat = 1) -> UIImage {
   let image = view.snapShotImage()
   
   if let source = image.CGImage {
       let context = CIContext(options: nil)
       let inputImage = CIImage(CGImage: source)
   
       let clampFilter = CIFilter(name: "CIAffineClamp")
       clampFilter?.setDefaults()
       clampFilter?.setValue(inputImage, forKey: kCIInputImageKey)
   
       if let clampedImage = clampFilter?.valueForKey(kCIOutputImageKey) as? CIImage {
           let explosureFilter = CIFilter(name: "CIExposureAdjust")
           explosureFilter?.setValue(clampedImage, forKey: kCIInputImageKey)
           explosureFilter?.setValue(-1.0, forKey: kCIInputEVKey)
   
           if let explosureImage = explosureFilter?.valueForKey(kCIOutputImageKey) as? CIImage {
               let filter = CIFilter(name: "CIGaussianBlur")
               filter?.setValue(explosureImage, forKey: kCIInputImageKey)
               filter?.setValue("\(radius)", forKey:kCIInputRadiusKey)
   
               if let result = filter?.valueForKey(kCIOutputImageKey) as? CIImage {
                   let bounds = UIScreen.mainScreen().bounds
                   let cgImage = context.createCGImage(result, fromRect: bounds)
                   let returnImage = UIImage(CGImage: cgImage)
                   return returnImage
               }
           }
       }
   }
   return UIImage()
   }

Cela a fonctionné pour moi sur Swift 5

let blurredView = UIVisualEffectView(effect: UIBlurEffect(style: .light))
blurredView.frame = self.view.bounds
backgroundimage.addSubview(blurredView)

Celui-ci garde toujours le bon cadre:

public extension UIView {

    @discardableResult
    public func addBlur(style: UIBlurEffect.Style = .extraLight) -> UIVisualEffectView {
        let blurEffect = UIBlurEffect(style: style)
        let blurBackground = UIVisualEffectView(effect: blurEffect)
        addSubview(blurBackground)
        blurBackground.translatesAutoresizingMaskIntoConstraints = false
        blurBackground.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
        blurBackground.topAnchor.constraint(equalTo: topAnchor).isActive = true
        blurBackground.leadingAnchor.constraint(equalTo: leadingAnchor).isActive = true
        blurBackground.trailingAnchor.constraint(equalTo: trailingAnchor).isActive = true
        return blurBackground
    }
}

Vous devez toujours utiliser .dark pour le style et ajouter le code suivant pour le rendre cool

    blurEffectView.backgroundColor = .black
    blurEffectView.alpha = 0.4

Ce code fonctionne très bien pour moi! c'est pour Swift 4.x

let blurEffect = UIBlurEffect(style: .ExtraLight)
let blurEffectView = UIVisualEffectView(effect: blurEffect)
blurEffectView.frame = self.view.frame
self.view.insertSubview(blurEffectView, atIndex: 0)

Trouvé une autre façon .. J'utilise UIImage + ImageEffects d'Apple.

 UIImage *effectImage = [image applyExtraLightEffect];                        
 self.imageView.image = effectImage;

Dans une extension UIView:

func addBlurredBackground(style: UIBlurEffect.Style) {
    let blurEffect = UIBlurEffect(style: style)
    let blurView = UIVisualEffectView(effect: blurEffect)
    blurView.frame = self.frame
    blurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
    self.addSubview(blurView)
    self.sendSubviewToBack(blurView)
}