Wie blur ein vorhandenes Bild in eine UIImageView mit Swift?

Ist das setup einfach.

  • Einen ViewController mit UIImageView, die hat ein Bild zugewiesen.
  • Ein UIButton, dass, wenn geklickt wird, wobei das Bild in der UIImageView.

Wie blur ein vorhandenes Bild in eine UIImageView mit Swift?

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var bg: UIImageView!

    @IBAction func blur(_ sender: Any) {
        let inputImage = CIImage(cgImage: (bg.image?.cgImage)!)

        let filter = CIFilter(name: "CIGaussianBlur")
        filter?.setValue(inputImage, forKey: "inputImage")
        filter?.setValue(10, forKey: "inputRadius")
        let blurred = filter?.outputImage
        bg.image = UIImage(ciImage: blurred!)
    }
}

Wenn der button geklickt wird der Bildschirm nur weiß wird. Kann nicht herausfinden, was ich falsch mache. Wer weiß, was ich falsch mache?

Werden Sie den Test auf einem echten Gerät oder im simulator? Einige CI-Filter (ich arbeite an einer maskierten blur jetzt) haben erbärmliche Leistung (denken in Bezug auf unter eine minute auf die Anzeige) in den simulator.
Überprüfen Sie bitte meine Antwort mit dem Github-link zu testen..

InformationsquelleAutor Mark Moeykens | 2016-12-15

  1. 18

    Können Sie einfach verwenden UIVisualEffect zu erreichen blur-Effekt. Als Sie versuchen, zu erreichen, einen Unschärfe-Effekt mit CoreImage.Probieren Sie folgenden code nach import CoreImage zu Ihrer Klasse.

    var context = CIContext(options: nil)

func blurEffect() {

    let currentFilter = CIFilter(name: "CIGaussianBlur") 
    let beginImage = CIImage(image: bg.image!)
    currentFilter!.setValue(beginImage, forKey: kCIInputImageKey)
    currentFilter!.setValue(10, forKey: kCIInputRadiusKey)

    let cropFilter = CIFilter(name: "CICrop")
    cropFilter!.setValue(currentFilter!.outputImage, forKey: kCIInputImageKey)
    cropFilter!.setValue(CIVector(cgRect: beginImage!.extent), forKey: "inputRectangle")

    let output = cropFilter!.outputImage 
    let cgimg = context.createCGImage(output!, from: output!.extent)
    let processedImage = UIImage(cgImage: cgimg!)
    bg.image = processedImage
}

    Ausgabe:

    Wie blur ein vorhandenes Bild in eine UIImageView mit Swift?

    Hinweis: empfehle ich Ihnen, testen Sie den code in Reale Gerät als Simulator Leistung ist zu langsam auf coreImage.

    Dies hat Super funktioniert. Ich wollte nicht zu verwenden UIVisualEffect weil ich wollte, um die Höhe der Unschärfe mit der inputRadius. Danke!
    Bitte sehen Sie hier für benutzerdefinierte Unschärfe scale stackoverflow.com/a/51406290/7576100

    InformationsquelleAutor Joe

  2. 12

    für diejenigen, die ❤ ️ - Protokolle

    protocol Bluring {
    func addBlur(_ alpha: CGFloat)
}

extension Bluring where Self: UIView {
    func addBlur(_ alpha: CGFloat = 0.5) {
        //create effect
        let effect = UIBlurEffect(style: .dark)
        let effectView = UIVisualEffectView(effect: effect)

        //set boundry and alpha
        effectView.frame = self.bounds
        effectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        effectView.alpha = alpha

        self.addSubview(effectView)
    }
}

//Conformance
extension UIView: Bluring {}

//use
someImageview.addBlur()
    Erstaunlich, danke!

    InformationsquelleAutor kaushal.exe

  3. 4

    Hier ist, wie ich mein erwartetes Ergebnis im SWIFT-3.1:
    Hoffe, es wird helfen.

    func blurImage(image:UIImage) -> UIImage? {
        let context = CIContext(options: nil)
        let inputImage = CIImage(image: image)
        let originalOrientation = image.imageOrientation
        let originalScale = image.scale

        let filter = CIFilter(name: "CIGaussianBlur")
        filter?.setValue(inputImage, forKey: kCIInputImageKey)
        filter?.setValue(10.0, forKey: kCIInputRadiusKey) 
        let outputImage = filter?.outputImage

        var cgImage:CGImage?

        if let asd = outputImage
        {
            cgImage = context.createCGImage(asd, from: (inputImage?.extent)!)
        }

        if let cgImageA = cgImage
        {
            return UIImage(cgImage: cgImageA, scale: originalScale, orientation: originalOrientation)
        }

        return nil
    }
    gute Antwort, die ich von Ihnen positiv bewertet werden, aber Folgen Sie bitte ein Code-Stil schreiben von code. Was zum Beispiel ist dieses: asd oder cgImageA. Sie können einfach schreiben: if let outputImage = outputImage { // }. Für mehr info check raywenderlich code-Stil, den ich verwenden: github.com/raywenderlich/swift-style-guide#optionals

    InformationsquelleAutor Md Milan Mia

  4. 0

    Ich aus der Unschärfe in ein NSObject Klasse, so kann ich die Verwendung dieser Methode im gesamten Projekt leicht.

    class Helper: NSObject
{
    class func addBlurView(_ inView : UIView) -> UIVisualEffectView
    {
        let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.dark)
        let blurEffectView = UIVisualEffectView(effect: blurEffect)

        //always fill the view
        blurEffectView.frame = inView.bounds
        blurEffectView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        blurEffectView.alpha = 0.5

        return blurEffectView
    }
}

    In ViewController machte ich ein Objekt der UIVisualEffectView. Rufen Sie dann die Methode der helper-Klasse zum hinzufügen von Unschärfe.

    import UIKit

class ViewController: UIViewController
{
   var blurEffectView : UIVisualEffectView!
    override func viewDidLoad() {
        super.viewDidLoad()

      blurEffectView = Helper.addBlurView((imgView)!)
      self.imgView.addSubview(blurEffectView)
}

    InformationsquelleAutor Amanpreet

  5. 0

    Verwenden: 

     import UIKit

    class ViewController: UIViewController {

        @IBOutlet weak var bgImageView: UIImageView!
        @IBOutlet weak var blurButton: UIButton!


        override func viewDidLoad() {
            super.viewDidLoad()
            //Do any additional setup after loading the view, typically from a nib.
        }

        override func didReceiveMemoryWarning() {
            super.didReceiveMemoryWarning()
            //Dispose of any resources that can be recreated.
        }


        @IBAction func blurButtonTapped(_ sender: Any) {

                let inputImage = CIImage(cgImage: (self.bgImageView.image?.cgImage)!)
                let filter = CIFilter(name: "CIGaussianBlur")
                filter?.setValue(inputImage, forKey: "inputImage")
                filter?.setValue(10, forKey: "inputRadius")
                let blurred = filter?.outputImage

                var newImageSize: CGRect = (blurred?.extent)!
                newImageSize.origin.x += (newImageSize.size.width - (self.bgImageView.image?.size.width)!) / 2
                newImageSize.origin.y += (newImageSize.size.height - (self.bgImageView.image?.size.height)!) / 2
                newImageSize.size = (self.bgImageView.image?.size)!

                let resultImage: CIImage = filter?.value(forKey: "outputImage") as! CIImage
                let context: CIContext = CIContext.init(options: nil)
                let cgimg: CGImage = context.createCGImage(resultImage, from: newImageSize)!
                let blurredImage: UIImage = UIImage.init(cgImage: cgimg)
                self.bgImageView.image = blurredImage
        }

    }

    Ausgabe:

    Wie blur ein vorhandenes Bild in eine UIImageView mit Swift?

    Gitbub link:

    https://github.com/k-sathireddy/ImageBlurEffect

    InformationsquelleAutor KSR

  6. 0

    Lösungen mit UIVisualEffectView oder CIFilter haben schreckliche Leistung oder schlechte Ergebnisse (Herstellung einer unscharfen hellen Rand um das Bild wie gesehen werden kann, in Joes Antwort) oder beides.

    Eines der leistungsstärksten Lösungen mit ordentlichen Ergebnissen ist StackBlur was nutzt einen cleveren Algorithmus, der effizient annähernd eine Unschärfe:

    Dies ist ein Kompromiss zwischen "Gaußscher Weichzeichner" und "Feld Weichzeichnen" Es schafft
    viel besser aussehend verwischt als "Feld Weichzeichnen", aber ist 7x schneller als mein
    Gaußscher Weichzeichner Umsetzung. Ich rief ihn legen Verschwimmen, weil dieser
    beschreibt am besten, wie dieser filter funktioniert auch intern: es schafft eine Art von
    bewegliche Stapel (oder vielleicht ein "Turm von Hanoi" Art von Struktur) von Farben
    während dem Scannen, die durch das Bild. Dieser "Turm" steuert die GEWICHTE
    aus den einzelnen Pixeln innerhalb der convolution kernel und gibt die pixel
    in der Mitte das höchste Gewicht. Das Geheimnis der Geschwindigkeit ist, dass die
    der Algorithmus hat nur zum hinzufügen neuer pixel auf der rechten Seite des Stapels
    und zur gleichen Zeit, entfernen Sie die am weitesten Links stehende pixel. Die restlichen Farben
    auf die oberste Schicht des Stapels sind entweder Hinzugefügt oder reduziert
    ein, je nachdem, ob Sie auf der rechten oder auf der linken Seite des
    stack.

    Check-out StackBlur auf Github.

    Gibt es viele Versionen gibt, auch Swift-ports, diese sind aber erheblich langsamer als die Obj-C-Versionen.

    InformationsquelleAutor Manuel

  7. -1

    Können Sie hinzufügen blur-Effekt durch UIBlurEffect und UIVisualEffectView:

    @IBAction func blur(_ sender: Any) {

    let darkBlur = UIBlurEffect(style: UIBlurEffectStyle.dark) 
    let blurView = UIVisualEffectView(effect: darkBlur)
    blurView.frame = bg_imagview.bounds
    blurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
    bg_imagview.addSubview(blurView)

}

    InformationsquelleAutor Bhavin Ramani

Schreibe einen Kommentar