Image Resizing Techniques

imageView.contentMode = .scaleAspectFit
imageView.image = image

func resizedImage(at url: URL, for size: CGSize) -> UIImage? {  }

imageView.image = resizedImage(at: url, for: size)

let scaleFactor = UIScreen.main.scale
let scale = CGAffineTransform(scaleX: scaleFactor, y: scaleFactor)
let size = imageView.bounds.size.applying(scale)

class ViewController: UIViewController {
    @IBOutlet var imageView: UIImageView!
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        let url = Bundle.main.url(forResource: "Blue Marble West",
                                  withExtension: "tiff")!
        
        DispatchQueue.global(qos: .userInitiated).async {
            let image = resizedImage(at: url, for: self.imageView.bounds.size)
            
            DispatchQueue.main.sync {
                UIView.transition(with: self.imageView,
                                  duration: 1.0,
                                  options: [.curveEaseOut, .transitionCrossDissolve],
                                  animations: {
                                    self.imageView.image = image
                                  })
            }
        }
    }
}

import UIKit

// 技巧 #1
func resizedImage(at url: URL, for size: CGSize) -> UIImage? {
 guard let image = UIImage(contentsOfFile: url.path) else {
 return nil
 }

 let renderer = UIGraphicsImageRenderer(size: size)
 return renderer.image { (context) in
 image.draw(in: CGRect(origin: .zero, size: size))
 }
}

import func AVFoundation.AVMakeRect
let rect = AVMakeRect(aspectRatio: image.size, insideRect: imageView.bounds)

import UIKit
import CoreGraphics

// 技巧 #2
func resizedImage(at url: URL, for size: CGSize) -> UIImage? {
 guard let imageSource = CGImageSourceCreateWithURL(url as NSURL, nil),
 let image = CGImageSourceCreateImageAtIndex(imageSource, 0, nil)
 else {
 return nil
 }

 let context = CGContext(data: nil,
 width: Int(size.width),
 height: Int(size.height),
 bitsPerComponent: image.bitsPerComponent,
 bytesPerRow: image.bytesPerRow,
 space: image.colorSpace ?? CGColorSpace(name: CGColorSpace.sRGB)!,
 bitmapInfo: image.bitmapInfo.rawValue)
 context?.interpolationQuality = .high
 context?.draw(image, in: CGRect(origin: .zero, size: size))

 guard let scaledImage = context?.makeImage() else { return nil }

 return UIImage(cgImage: scaledImage)
}

import ImageIO

// 技巧 #3
func resizedImage(at url: URL, for size: CGSize) -> UIImage? {
 let options: [CFString: Any] = [
 kCGImageSourceCreateThumbnailFromImageIfAbsent: true,
 kCGImageSourceCreateThumbnailWithTransform: true,
 kCGImageSourceShouldCacheImmediately: true,
 kCGImageSourceThumbnailMaxPixelSize: max(size.width, size.height)
 ]

 guard let imageSource = CGImageSourceCreateWithURL(url as NSURL, nil),
 let image = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, options as CFDictionary)
 else {
 return nil
 }

 return UIImage(cgImage: image)
}

import UIKit
import CoreImage

let sharedContext = CIContext(options: [.useSoftwareRenderer : false])

// 技巧 #4
func resizedImage(at url: URL, scale: CGFloat, aspectRatio: CGFloat) -> UIImage? {
 guard let image = CIImage(contentsOf: url) else {
 return nil
 }

 let filter = CIFilter(name: "CILanczosScaleTransform")
 filter?.setValue(image, forKey: kCIInputImageKey)
 filter?.setValue(scale, forKey: kCIInputScaleKey)
 filter?.setValue(aspectRatio, forKey: kCIInputAspectRatioKey)

 guard let outputCIImage = filter?.outputImage,
 let outputCGImage = sharedContext.createCGImage(outputCIImage,
 from: outputCIImage.extent)
 else {
 return nil
 }

 return UIImage(cgImage: outputCGImage)
}

import UIKit
import Accelerate.vImage

// 技巧 #5
func resizedImage(at url: URL, for size: CGSize) -> UIImage? {
 // 解码源图像
 guard let imageSource = CGImageSourceCreateWithURL(url as NSURL, nil),
 let image = CGImageSourceCreateImageAtIndex(imageSource, 0, nil),
 let properties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) as? [CFString: Any],
 let imageWidth = properties[kCGImagePropertyPixelWidth] as? vImagePixelCount,
 let imageHeight = properties[kCGImagePropertyPixelHeight] as? vImagePixelCount
 else {
 return nil
 }

 // 定义图像格式
 var format = vImage_CGImageFormat(bitsPerComponent: 8,
 bitsPerPixel: 32,
 colorSpace: nil,
 bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.first.rawValue),
 version: 0,
 decode: nil,
 renderingIntent: .defaultIntent)

 var error: vImage_Error

 // 创建并初始化源缓冲区
 var sourceBuffer = vImage_Buffer()
 defer { sourceBuffer.data.deallocate() }
 error = vImageBuffer_InitWithCGImage(&sourceBuffer,
 &format,
 nil,
 image,
 vImage_Flags(kvImageNoFlags))
 guard error == kvImageNoError else { return nil }

 // 创建并初始化目标缓冲区
 var destinationBuffer = vImage_Buffer()
 error = vImageBuffer_Init(&destinationBuffer,
 vImagePixelCount(size.height),
 vImagePixelCount(size.width),
 format.bitsPerPixel,
 vImage_Flags(kvImageNoFlags))
 guard error == kvImageNoError else { return nil }

 // 优化缩放图像
 error = vImageScale_ARGB8888(&sourceBuffer,
 &destinationBuffer,
 nil,
 vImage_Flags(kvImageHighQualityResampling))
 guard error == kvImageNoError else { return nil }

 // 从目标缓冲区创建一个 CGImage 对象
 guard let resizedImage =
 vImageCreateCGImageFromBuffer(&destinationBuffer,
 &format,
 nil,
 nil,
 vImage_Flags(kvImageNoAllocate),
 &error)?.takeRetainedValue(),
 error == kvImageNoError
 else {
 return nil
 }

 return UIImage(cgImage: resizedImage)
}