Mein Code funktioniert gut für normale Geräte, erzeugt jedoch verschwommene Bilder auf Retina-Geräten.

Kennt jemand eine Lösung für mein Problem?

+ (UIImage *) imageWithView:(UIView *)view
{
    UIGraphicsBeginImageContext(view.bounds.size);
    [view.layer renderInContext:UIGraphicsGetCurrentContext()];

    UIImage * img = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();

    return img;
}

Wechseln Sie von Verwendung UIGraphicsBeginImageContextzu UIGraphicsBeginImageContextWithOptions(wie auf dieser Seite dokumentiert ). Übergeben Sie 0.0 für scale (das dritte Argument) und Sie erhalten einen Kontext mit einem Skalierungsfaktor, der dem des Bildschirms entspricht.

UIGraphicsBeginImageContextverwendet einen festen Skalierungsfaktor von 1,0, sodass Sie auf einem iPhone 4 genau das gleiche Bild erhalten wie auf den anderen iPhones. Ich wette, entweder das iPhone 4 wendet einen Filter an, wenn Sie ihn implizit vergrößern, oder nur Ihr Gehirn erkennt, dass er weniger scharf ist als alles um ihn herum.

Also, ich denke:

#import <QuartzCore/QuartzCore.h>

+ (UIImage *)imageWithView:(UIView *)view
{
    UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.opaque, 0.0);
    [view.layer renderInContext:UIGraphicsGetCurrentContext()];

    UIImage * img = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();

    return img;
}

Und in Swift 4:

func image(with view: UIView) -> UIImage? {
    UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.isOpaque, 0.0)
    defer { UIGraphicsEndImageContext() }
    if let context = UIGraphicsGetCurrentContext() {
        view.layer.render(in: context)
        let image = UIGraphicsGetImageFromCurrentImageContext()
        return image
    }
    return nil
}

Die derzeit akzeptierte Antwort ist veraltet, zumindest wenn Sie iOS 7 unterstützen.

Folgendes sollten Sie verwenden, wenn Sie nur iOS7 + unterstützen:

+ (UIImage *) imageWithView:(UIView *)view
{
    UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.opaque, 0.0f);
    [view drawViewHierarchyInRect:view.bounds afterScreenUpdates:NO];
    UIImage * snapshotImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return snapshotImage;
}

Swift 4:

func imageWithView(view: UIView) -> UIImage? {
    UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.isOpaque, 0.0)
    defer { UIGraphicsEndImageContext() }
    view.drawHierarchy(in: view.bounds, afterScreenUpdates: true)
    return UIGraphicsGetImageFromCurrentImageContext()
}

In diesem Artikel sehen Sie, dass die neue iOS7-Methode drawViewHierarchyInRect:afterScreenUpdates:um ein Vielfaches schneller ist als renderInContext:.

Ich habe eine Swift-Erweiterung basierend auf der @ Dima-Lösung erstellt:

extension UIImage {
    class func imageWithView(view: UIView) -> UIImage {
        UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.opaque, 0.0)
        view.drawViewHierarchyInRect(view.bounds, afterScreenUpdates: true)
        let img = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return img
    }
}

EDIT: Swift 4 verbesserte Version

extension UIImage {
    class func imageWithView(_ view: UIView) -> UIImage {
        UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.isOpaque, 0)
        defer { UIGraphicsEndImageContext() }
        view.drawHierarchy(in: view.bounds, afterScreenUpdates: true)
        return UIGraphicsGetImageFromCurrentImageContext() ?? UIImage()
    }
}

Verwendungszweck:

let view = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))  
let image = UIImage.imageWithView(view)

Verwendung des modernen UIGraphicsImageRenderer

public extension UIView {
    @available(iOS 10.0, *)
    public func renderToImage(afterScreenUpdates: Bool = false) -> UIImage {
        let rendererFormat = UIGraphicsImageRendererFormat.default()
        rendererFormat.opaque = isOpaque
        let renderer = UIGraphicsImageRenderer(size: bounds.size, format: rendererFormat)

        let snapshotImage = renderer.image { _ in
            drawHierarchy(in: bounds, afterScreenUpdates: afterScreenUpdates)
        }
        return snapshotImage
    }
}

Um die Antworten von @Tommy und @Dima zu verbessern, verwenden Sie die folgende Kategorie, um UIView mit transparentem Hintergrund und ohne Qualitätsverlust in UIImage zu rendern . Arbeiten an iOS7. (Oder verwenden Sie diese Methode einfach in der Implementierung wieder und ersetzen Sie die selfReferenz durch Ihr Bild.)

UIView + RenderViewToImage.h

#import <UIKit/UIKit.h>

@interface UIView (RenderToImage)

- (UIImage *)imageByRenderingView;

@end

UIView + RenderViewToImage.m

#import "UIView+RenderViewToImage.h"

@implementation UIView (RenderViewToImage)

- (UIImage *)imageByRenderingView
{
    UIGraphicsBeginImageContextWithOptions(self.bounds.size, NO, 0.0);
    [self drawViewHierarchyInRect:self.bounds afterScreenUpdates:YES];
    UIImage * snapshotImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return snapshotImage;
}

@end

Swift 3

Die Swift 3- Lösung (basierend auf Dimas Antwort ) mit UIView-Erweiterung sollte folgendermaßen aussehen:

extension UIView {
    public func getSnapshotImage() -> UIImage {
        UIGraphicsBeginImageContextWithOptions(self.bounds.size, self.isOpaque, 0)
        self.drawHierarchy(in: self.bounds, afterScreenUpdates: false)
        let snapshotImage: UIImage = UIGraphicsGetImageFromCurrentImageContext()!
        UIGraphicsEndImageContext()
        return snapshotImage
    }
}

Drop-in Swift 3.0-Erweiterung, die die neue iOS 10.0-API und die vorherige Methode unterstützt.

Hinweis:

• iOS-Versionsprüfung
• Beachten Sie die Verwendung von Defer, um die Kontextbereinigung zu vereinfachen.
• Wendet auch die Deckkraft und den aktuellen Maßstab der Ansicht an.
• Nichts wird nur mit ausgepackt, !was zu einem Absturz führen könnte.

extension UIView
{
    public func renderToImage(afterScreenUpdates: Bool = false) -> UIImage?
    {
        if #available(iOS 10.0, *)
        {
            let rendererFormat = UIGraphicsImageRendererFormat.default()
            rendererFormat.scale = self.layer.contentsScale
            rendererFormat.opaque = self.isOpaque
            let renderer = UIGraphicsImageRenderer(size: self.bounds.size, format: rendererFormat)

            return
                renderer.image
                {
                    _ in

                    self.drawHierarchy(in: self.bounds, afterScreenUpdates: afterScreenUpdates)
                }
        }
        else
        {
            UIGraphicsBeginImageContextWithOptions(self.bounds.size, self.isOpaque, self.layer.contentsScale)
            defer
            {
                UIGraphicsEndImageContext()
            }

            self.drawHierarchy(in: self.bounds, afterScreenUpdates: afterScreenUpdates)

            return UIGraphicsGetImageFromCurrentImageContext()
        }
    }
}

Swift 2.0:

Verwenden der Erweiterungsmethode:

extension UIImage{

   class func renderUIViewToImage(viewToBeRendered:UIView?) -> UIImage
   {
       UIGraphicsBeginImageContextWithOptions((viewToBeRendered?.bounds.size)!, false, 0.0)
       viewToBeRendered!.drawViewHierarchyInRect(viewToBeRendered!.bounds, afterScreenUpdates: true)
       viewToBeRendered!.layer.renderInContext(UIGraphicsGetCurrentContext()!)

       let finalImage = UIGraphicsGetImageFromCurrentImageContext()
       UIGraphicsEndImageContext()

       return finalImage
   }

}

Verwendungszweck:

override func viewDidLoad() {
    super.viewDidLoad()

    //Sample View To Self.view
    let sampleView = UIView(frame: CGRectMake(100,100,200,200))
    sampleView.backgroundColor =  UIColor(patternImage: UIImage(named: "ic_120x120")!)
    self.view.addSubview(sampleView)    

    //ImageView With Image
    let sampleImageView = UIImageView(frame: CGRectMake(100,400,200,200))

    //sampleView is rendered to sampleImage
    var sampleImage = UIImage.renderUIViewToImage(sampleView)

    sampleImageView.image = sampleImage
    self.view.addSubview(sampleImageView)

 }

Schnelle 3.0-Implementierung

extension UIView {
    func getSnapshotImage() -> UIImage {
        UIGraphicsBeginImageContextWithOptions(bounds.size, isOpaque, 0)
        drawHierarchy(in: bounds, afterScreenUpdates: false)
        let snapshotImage = UIGraphicsGetImageFromCurrentImageContext()!
        UIGraphicsEndImageContext()
        return snapshotImage
    }
}

Alle Swift 3-Antworten haben bei mir nicht funktioniert, daher habe ich die am meisten akzeptierte Antwort übersetzt:

extension UIImage {
    class func imageWithView(view: UIView) -> UIImage {
        UIGraphicsBeginImageContextWithOptions(view.bounds.size, view.isOpaque, 0.0)
        view.layer.render(in: UIGraphicsGetCurrentContext()!)
        let img: UIImage? = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return img!
    }
}

Hier ist eine Swift 4 UIView-Erweiterung, die auf der Antwort von @Dima basiert.

extension UIView {
   func snapshotImage() -> UIImage? {
       UIGraphicsBeginImageContextWithOptions(bounds.size, isOpaque, 0)
       drawHierarchy(in: bounds, afterScreenUpdates: false)
       let image = UIGraphicsGetImageFromCurrentImageContext()
       UIGraphicsEndImageContext()
       return image
   }
}

Für Swift 5.1 können Sie diese Erweiterung verwenden:

extension UIView {

    func asImage() -> UIImage {
        let renderer = UIGraphicsImageRenderer(bounds: bounds)

        return renderer.image {
            rendererContext in

            layer.render(in: rendererContext.cgContext)
        }
    }
}

UIGraphicsImageRendererist eine relativ neue API, die in iOS 10 eingeführt wurde. Sie erstellen einen UIGraphicsImageRenderer, indem Sie eine Punktgröße angeben . Die Bildmethode verwendet ein Abschlussargument und gibt eine Bitmap zurück, die sich aus der Ausführung des übergebenen Abschlusses ergibt. In diesem Fall ist das Ergebnis das Originalbild, das verkleinert wurde, um innerhalb der angegebenen Grenzen zu zeichnen.

https://nshipster.com/image-resizing/

UIGraphicsImageRendererStellen Sie also sicher, dass die Größe, in die Sie übergeben, Punkte und keine Pixel sind.

Wenn Ihre Bilder größer sind als erwartet, müssen Sie Ihre Größe durch den Skalierungsfaktor teilen.

Manchmal macht die drawRect-Methode ein Problem, daher habe ich diese Antworten besser erhalten. Vielleicht sehen auch Sie es sich an. Erfassen Sie UIImage von UIView, das in der DrawRect-Methode steckt

- (UIImage*)screenshotForView:(UIView *)view
{
    UIGraphicsBeginImageContext(view.bounds.size);
    [view.layer renderInContext:UIGraphicsGetCurrentContext()];
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    // hack, helps w/ our colors when blurring
    NSData *imageData = UIImageJPEGRepresentation(image, 1); // convert to jpeg
    image = [UIImage imageWithData:imageData];

    return image;
}

Bei dieser Methode übergeben Sie einfach ein Ansichtsobjekt und es wird ein UIImage-Objekt zurückgegeben.

-(UIImage*)getUIImageFromView:(UIView*)yourView
{
 UIGraphicsBeginImageContext(yourView.bounds.size);
 [yourView.layer renderInContext:UIGraphicsGetCurrentContext()];
 UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
 UIGraphicsEndImageContext();
 return image;
}

Fügen Sie diese Methode zur UIView-Kategorie hinzu

- (UIImage*) capture {
    UIGraphicsBeginImageContext(self.bounds.size);
    CGContextRef context = UIGraphicsGetCurrentContext();
    [self.layer renderInContext:context];
    UIImage *img = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return img;
}