Obraz w skali do mniejszego rozmiaru w swift3

Question

Próbuję przeskalować obraz, który jest graficznie zaprogramowany w galerii zdjęć. Próbuję przeskalować obraz, aby go zmniejszyć. Jak użyć kodu poniżej, aby obraz mniejszy

image1.scale 

Answer 1

używać tego rozszerzenia, aby zmienić rozmiar obrazu:

extension UIImage{ 

func resizeImageWith(newSize: CGSize) -> UIImage { 

    let horizontalRatio = newSize.width/size.width 
    let verticalRatio = newSize.height/size.height 

    let ratio = max(horizontalRatio, verticalRatio) 
    let newSize = CGSize(width: size.width * ratio, height: size.height * ratio) 
    UIGraphicsBeginImageContextWithOptions(newSize, true, 0) 
    draw(in: CGRect(origin: CGPoint(x: 0, y: 0), size: newSize)) 
    let newImage = UIGraphicsGetImageFromCurrentImageContext() 
    UIGraphicsEndImageContext() 
    return newImage! 
    } 


} 

Zasadniczo są obliczenia proporcji, aby zachować obraz nietknięty podczas zmiany rozmiaru go. Następnie otrzymujesz bieżący kontekst obrazu i rysujesz go w określonym prostokącie, a następnie zwracasz go jako nowy obraz.

Answer 2

Spróbuj tego:

Pierwsza metoda:

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 
} 

Druga metoda:

import UIKit 

func RBSquareImageTo(image: UIImage, size: CGSize) -> UIImage { 
    return RBResizeImage(RBSquareImage(image), size) 
} 

func RBSquareImage(image: UIImage) -> UIImage { 
    var originalWidth = image.size.width 
    var originalHeight = image.size.height 

    var edge: CGFloat 
if originalWidth > originalHeight { 
    edge = originalHeight 
} else { 
    edge = originalWidth 
} 

var posX = (originalWidth - edge)/2.0 
var posY = (originalHeight - edge)/2.0 

var cropSquare = CGRectMake(posX, posY, edge, edge) 

var imageRef = CGImageCreateWithImageInRect(image.CGImage, cropSquare); 
return UIImage(CGImage: imageRef, scale: UIScreen.mainScreen().scale, orientation: image.imageOrientation) 
} 

func RBResizeImage(image: UIImage, targetSize: CGSize) -> UIImage { 
let size = image.size 

let widthRatio = targetSize.width/image.size.width 
let heightRatio = targetSize.height/image.size.height 

// Figure out what our orientation is, and use that to form the rectangle 
var newSize: CGSize 
if(widthRatio > heightRatio) { 
    newSize = CGSizeMake(size.width * heightRatio, size.height * heightRatio) 
} else { 
    newSize = CGSizeMake(size.width * widthRatio, size.height * widthRatio) 
} 

// This is the rect that we've calculated out and this is what is actually used below 
let rect = CGRectMake(0, 0, newSize.width, newSize.height) 

// Actually do the resizing to the rect using the ImageContext stuff 
UIGraphicsBeginImageContextWithOptions(newSize, false, 1.0) 
image.drawInRect(rect) 
let newImage = UIGraphicsGetImageFromCurrentImageContext() 
UIGraphicsEndImageContext() 

return newImage 
    } 

referencyjny:

1. Here

2. Here

Answer 3

Może to być pomocne, metoda ta zrobi proporcjonalną zmianę rozmiaru obrazu o dobrej jakości.

func resizeImage(image: UIImage, withSize: CGSize) -> UIImage { 

    var actualHeight: CGFloat = image.size.height 
    var actualWidth: CGFloat = image.size.width 
    let maxHeight: CGFloat = withSize.width 
    let maxWidth: CGFloat = withSize.height 
    var imgRatio: CGFloat = actualWidth/actualHeight 
    let maxRatio: CGFloat = maxWidth/maxHeight 
    let compressionQuality = 0.5//50 percent compression 

    if (actualHeight > maxHeight || actualWidth > maxWidth) { 
     if(imgRatio < maxRatio) { 
      //adjust width according to maxHeight 
      imgRatio = maxHeight/actualHeight 
      actualWidth = imgRatio * actualWidth 
      actualHeight = maxHeight 
     } else if(imgRatio > maxRatio) { 
      //adjust height according to maxWidth 
      imgRatio = maxWidth/actualWidth 
      actualHeight = imgRatio * actualHeight 
      actualWidth = maxWidth 
     } else { 
      actualHeight = maxHeight 
      actualWidth = maxWidth 
     } 
    } 

    let rect: CGRect = CGRect(x: 0.0, y: 0.0, width: actualWidth, height: actualHeight) 
    UIGraphicsBeginImageContext(rect.size) 
    image.draw(in: rect) 
    let image: UIImage = UIGraphicsGetImageFromCurrentImageContext()! 
    let imageData = UIImageJPEGRepresentation(image, CGFloat(compressionQuality)) 
    UIGraphicsEndImageContext() 

    let resizedImage = UIImage(data: imageData!) 
    return resizedImage! 

} 

nazywają to metody, takie jak ten,

resizeImage(image: UIImage(named: "ImageName"), withSize: CGSize(width: 300, height: 300)) 

Dzięki :)

Answer 4

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 image = info[UIImagePickerControllerOriginalImage] as? UIImage 
    let scaledImage:UIImage = resizeImage(image!, newWidth: 200) 
    self.dismissViewControllerAnimated(true, completion: nil) 

}