Resize UIImage to 200x200pt/px

I have been struggling resizing an image.
Basically I have stumpled upon:
How to scale down a UIImage and make it crispy / sharp at the same time instead of blurry?

This seems to be a legit solution but somehow it is not working correctly.

  • Adding a TabBarController programmatically
  • does dispatch_async copy internal blocks
  • I am getting data from json web services but unable to display it on my ui
  • How to addSubview with a position?
  • How to add bottom border to tableview section header
  • binary operator * cannot be applied to operands of type Int and Double
  • My app works with Photos from the Camera Roll. This photos should be resized to about 200×200 whereas the width is important, not the height.

    Unfortunetly I am not having a sample code as I discarded it in my rage about non working solution, sorry.

    10 Solutions Collect From Internet About “Resize UIImage to 200x200pt/px”

    Here is my code. The Image is in width 850 px and not 200 px:

     func resizeImage(image: UIImage, newWidth: CGFloat) -> UIImage {
    
        let scale = newWidth / image.size.width
        let newHeight = image.size.height * scale
        UIGraphicsBeginImageContext(CGSizeMake(newWidth, newHeight))
        image.drawInRect(CGRectMake(0, 0, newWidth, newHeight))
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
    
        return newImage
    }
    
    
    @IBAction func chooseImage(sender: AnyObject) {
    
    
        var myPickerController = UIImagePickerController()
        myPickerController.sourceType = UIImagePickerControllerSourceType.PhotoLibrary
        myPickerController.delegate = self;
        self.presentViewController(myPickerController, animated: true, completion: nil)
    
    
    }
    
    func imagePickerController(picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [NSObject : AnyObject])
    
    {
        var imagenow = info[UIImagePickerControllerOriginalImage] as? UIImage
    
        imageImage.image = resizeImage(imagenow!, newWidth: 200)
    
    
    
        pimg2 = imageImage.image!
    
        cidnew2 = textFieldCID!.text!
        pname2 = textFieldName!.text
        pmanu2 = textFieldMan!.text
        pnick2 = textFieldNick!.text
        podate2 = textFieldPODate!.text
        pno2 = textFieldArtNo!.text
    
    
    
        self.dismissViewControllerAnimated(true, completion: nil)
    
    }
    

    Based on swift_dan’s answer, an update for Swift 3

    func resizeImage(image: UIImage, newWidth: CGFloat) -> UIImage? {
    
        let scale = newWidth / image.size.width
        let newHeight = image.size.height * scale
        UIGraphicsBeginImageContext(CGSize(width: newWidth, height: newHeight))
        image.draw(in: CGRect(x: 0, y: 0, width: newWidth, height: newHeight))
    
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
    
        return newImage
    }
    

    If you’re dealing with PNG images that contain transparencies, then the accepted answer function will actually convert the transparent areas to black.

    If you wish to scale and keep the transparencies in place, try this function:

    SWIFT 3

     extension UIImage {
    
        func scaleImage(toSize newSize: CGSize) -> UIImage? {
            let newRect = CGRect(x: 0, y: 0, width: newSize.width, height: newSize.height).integral
            UIGraphicsBeginImageContextWithOptions(newSize, false, 0)
            if let context = UIGraphicsGetCurrentContext() {
                context.interpolationQuality = .high
                let flipVertical = CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: newSize.height)
                context.concatenate(flipVertical)
                context.draw(self.cgImage!, in: newRect)
                let newImage = UIImage(cgImage: context.makeImage()!)
                UIGraphicsEndImageContext()
                return newImage
            }
            return nil
        }
    }
    

    For Swift 3.0

    simply add this snippet as extension to UIImage. However, remember that is not going to make the image in square form but if it was in that form, the result will be square.

    extension UIImage {
        func resizeImage(newWidth: CGFloat) -> UIImage {
    
            let scale = newWidth / self.size.width
            let newHeight = self.size.height * scale
            UIGraphicsBeginImageContext(CGSize(width: newWidth, height: newHeight))
            self.draw(in: CGRect(x: 0, y: 0, width: newWidth, height: newHeight))
            let newImage = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()
    
            return newImage!
        } }
    

    This function will return an image with width you specified:

    func scaleImage(image: UIImage, maximumWidth: CGFloat) -> UIImage {
        let rect: CGRect = CGRectMake(0, 0, image.size.width, image.size.height)
        let cgImage: CGImageRef = CGImageCreateWithImageInRect(image.CGImage!, rect)!
        return UIImage(CGImage: cgImage, scale: image.size.width / maximumWidth, orientation: image.imageOrientation)
    }
    

    Swift 3.0

    func scaledImage(_ image: UIImage, maximumWidth: CGFloat) -> UIImage {
        let rect: CGRect = CGRect(x: 0, y: 0, width: image.size.width, height: image.size.height)
        let cgImage: CGImage = image.cgImage!.cropping(to: rect)!
        return UIImage(cgImage: cgImage, scale: image.size.width / maximumWidth, orientation: image.imageOrientation)
    }
    

    Swift 4.0 –

    If you’re dealing with images that contain transparencies, then the accepted answer function will actually convert the transparent areas to black.

    If you wish to scale and keep the transparencies in place, try this function:

    func resizeImageWith(image: UIImage, newSize: CGSize) -> UIImage {
    
        let horizontalRatio = newSize.width / image.size.width
        let verticalRatio = newSize.height / image.size.height
    
        let ratio = max(horizontalRatio, verticalRatio)
        let newSize = CGSize(width: image.size.width * ratio, height: image.size.height * ratio)
        var newImage: UIImage
    
        if #available(iOS 10.0, *) {
            let renderFormat = UIGraphicsImageRendererFormat.default()
            renderFormat.opaque = false
            let renderer = UIGraphicsImageRenderer(size: CGSize(width: newSize.width, height: newSize.height), format: renderFormat)
            newImage = renderer.image {
                (context) in
                image.draw(in: CGRect(x: 0, y: 0, width: newSize.width, height: newSize.height))
            }
        } else {
            UIGraphicsBeginImageContextWithOptions(CGSize(width: newSize.width, height: newSize.height), isOpaque, 0)
            image.draw(in: CGRect(x: 0, y: 0, width: newSize.width, height: newSize.height))
            newImage = UIGraphicsGetImageFromCurrentImageContext()!
            UIGraphicsEndImageContext()
        }
    
        return newImage
    }
    
    func getScaledDimension(width: CGFloat, height: CGFloat,new_width: CGFloat, new_height: CGFloat)->CGPoint {
    
            let widthAspect =  (width / new_width)
            let heightAspect = (height / new_height)
            if widthAspect == 0 || heightAspect == 0 {
                return CGPoint(x: width, y: height)
            }
            var width1 : CGFloat = 0
            var height1 : CGFloat =  0
            if widthAspect > heightAspect {
                width1 = (width) / heightAspect
                height1 = (height) / heightAspect
            } else {
                width1 = (width) / widthAspect
                height1 = (height) / widthAspect
            }
    
            return CGPoint(x: width1, y: height1 )
        }
    
    
    
        func ResizeImage(image: UIImage, targetSize: CGSize) -> UIImage {
    
            let rect = CGRectMake(0, 0, targetSize.width, targetSize.height)
    
            UIGraphicsBeginImageContextWithOptions(targetSize, false, 1.0)
            image.drawInRect(rect)
            let newImage = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()
    
            return newImage
        }
    
    
     let imagesize =  getScaledDimension(image.size.width, height: image.size.height , new_width: Width, new_height: Hieght)
    
            print("Image Size Scaled Dimension -> H:\(imagesize.x) W:\(imagesize.y)")
    
            let newImage = ResizeImage(image, targetSize: CGSizeMake(imagesize.x,imagesize.y))
            print("Resize Image Size -> H\(newImage.size.height) W\(newImage.size.width) ")
    

    If you are using kingfisher lib for loading images in you project and want to resize it here is the way:

  • Xcode 8
  • Swift 3x
  • let imageUrl = URL(string: "your image url")
     //Size refer to the size which you want to resize your original image
     let size = CGSize(width: 60, height: 60)
     let processImage = ResizingImageProcessor(targetSize: size, contentMode: .aspectFit)
     cell.courseTitleImage.kf.setImage(with: imageUrl! , placeholder: UIImage(named: "placeholder"), options: [.transition(ImageTransition.fade(1)), .processor(processImage)], progressBlock: nil, completionHandler: nil)
    

    OR

    Resize Local Image:-
    you can refer to the answer of @Christoph R

    Reduce image size by 1024, you can always convert according server capacity

    func resizeImage(image: UIImage) -> UIImage {

        if image.size.height >= 1024 && image.size.width >= 1024 {
    
            UIGraphicsBeginImageContext(CGSize(width:1024, height:1024))
            image.draw(in: CGRect(x:0, y:0, width:1024, height:1024))
    
            let newImage = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()
    
            return newImage!
    
        }
        else if image.size.height >= 1024 && image.size.width < 1024
        {
    
            UIGraphicsBeginImageContext(CGSize(width:image.size.width, height:1024))
            image.draw(in: CGRect(x:0, y:0, width:image.size.width, height:1024))
    
            let newImage = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()
    
            return newImage!
    
        }
        else if image.size.width >= 1024 && image.size.height < 1024
        {
    
            UIGraphicsBeginImageContext(CGSize(width:1024, height:image.size.height))
            image.draw(in: CGRect(x:0, y:0, width:1024, height:image.size.height))
    
            let newImage = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()
    
            return newImage!
    
        }
        else
        {
            return image
        }
    
    }
    

    This code uses UIGraphicsImageRenderer introduced in iOS 10: in my testing it was 10-40% faster than earlier samples with UIGraphicsBeginImageContext (Swift 4 / Xcode 9):

    extension UIImage {
        func renderResizedImage (newWidth: CGFloat) -> UIImage {
        let scale = newWidth / self.size.width
        let newHeight = self.size.height * scale
        let newSize = CGSize(width: newWidth, height: newHeight)
    
        let renderer = UIGraphicsImageRenderer(size: newSize)
    
        let image = renderer.image { (context) in
            self.draw(in: CGRect(origin: CGPoint(x: 0, y: 0), size: newSize))
        }
        return image
    }
    

    }