uiimagecop.swift

import Foundation
import GLKit

extension UIImage {

    func checkAndCompressImage(image: UIImage?, _ completion: @escaping (Data?) -> Void) {
        print("start compress image ....")
        DispatchQueue.global(qos: .background).async {
            let imagecompress = UIImage.compressImage(image, compressRatio: 0.5)
            
            completion(imagecompress)
            
            print("finish compress image ....")
            
        }
        
    }
    
    class func compressImage(_ image: UIImage?, compressRatio ratio: CGFloat) -> Data? {
        return compressImage(image, compressRatio: ratio, maxCompressRatio: 0.1)
    }
    
    class func scaleDown(_ image: UIImage?, with newSize: CGSize) -> UIImage? {
        
        //We prepare a bitmap with the new size
        UIGraphicsBeginImageContextWithOptions(newSize, _: true, _: 0.0)
        
        //Draws a rect for the image
        image?.draw(in: CGRect(x: 0, y: 0, width: newSize.width, height: newSize.height))
        
        //We set the scaled image from the context
        let scaledImage: UIImage? = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        
        return scaledImage
    }
    
    class func compressImage(_ image: UIImage?, compressRatio ratio: CGFloat, maxCompressRatio maxRatio: CGFloat) -> Data? {
        var image = image
        
        //We define the max and min resolutions to shrink to
        let minUploadResolution: Int = 1136 * 640
        let maxUploadSize: Int = 50
        
        var factor: Float
        let currentResolution = Float((image?.size.height ?? 0.0) * (image?.size.width ?? 0.0))
        
        //We first shrink the image a little bit in order to compress it a little bit more
        if currentResolution > Float(minUploadResolution) {
            factor = sqrt(currentResolution / Float(minUploadResolution)) * 2
            image = self.scaleDown(image, with: CGSize(width: (image?.size.width ?? 0.0) / CGFloat(factor), height: (image?.size.height ?? 0.0) / CGFloat(factor)))
        }
        
        //Compression settings
        var compression: CGFloat = ratio
        let maxCompression: CGFloat = maxRatio
        
        //We loop into the image data to compress accordingly to the compression ratio
        var imageData = image?.jpegData(compressionQuality: compression)
        while (imageData?.count ?? 0) > maxUploadSize && compression > maxCompression {
            compression -= 0.10
            imageData = image?.jpegData(compressionQuality: compression)
        }
        
        //Retuns the compressed image
        return imageData//UIImage(data: imageData ?? Data())
    }
    class func compressRemoteImage(_ url: String?, compressRatio ratio: CGFloat, maxCompressRatio maxRatio: CGFloat) -> Data? {
        //Parse the URL
        let imageURL = URL(string: url ?? "")
        
        //We init the image with the rmeote data
        var remoteImage: UIImage?
        if let imageURL = imageURL, let data = try? Data(contentsOf: imageURL) {
            remoteImage = UIImage(data: data)
        }
        
        //Returns the remote image compressed
        return self.compressImage(remoteImage, compressRatio: ratio, maxCompressRatio: maxRatio)
        
    }
    class func compressRemoteImage(_ url: String?, compressRatio ratio: CGFloat) -> Data? {
        return self.compressRemoteImage(url, compressRatio: ratio, maxCompressRatio: 0.1)
    }
}