Ποιος είναι ο ευκολότερος τρόπος για να αλλάξετε το μέγεθος / βελτιστοποίηση ένα μέγεθος εικόνας με το iPhone SDK;

Ο πιο εύκολος και απλός τρόπος για να αλλάξετε το μέγεθος των εικόνων σας θα είναι αυτό

float actualHeight = image.size.height;
float actualWidth = image.size.width;
float imgRatio = actualWidth/actualHeight;
float maxRatio = 320.0/480.0;

if(imgRatio!=maxRatio){
    if(imgRatio < maxRatio){
        imgRatio = 480.0 / actualHeight;
        actualWidth = imgRatio * actualWidth;
        actualHeight = 480.0;
    }
    else{
        imgRatio = 320.0 / actualWidth;
        actualHeight = imgRatio * actualHeight;
        actualWidth = 320.0;
    }
}
CGRect rect = CGRectMake(0.0, 0.0, actualWidth, actualHeight);
UIGraphicsBeginImageContext(rect.size);
[image drawInRect:rect];
UIImage *img = UIGraphicsGetImageFromCurrentImageContext();
UIGraphicsEndImageContext();

Οι παραπάνω μέθοδοι λειτουργούν καλά για μικρές εικόνες, αλλά όταν προσπαθείτε να αλλάξετε το μέγεθος μια πολύ μεγάλη εικόνα, θα τρέξει γρήγορα έξω από τη μνήμη και την συντριβή της εφαρμογής. Ένας καλύτερος τρόπος είναι να χρησιμοποιήσετε CGImageSourceCreateThumbnailAtIndexγια να αλλάξετε το μέγεθος της εικόνας, χωρίς εντελώς το αποκωδικοποίηση για πρώτη φορά.

Αν έχετε τη διαδρομή προς την εικόνα που θέλετε να αλλάξετε το μέγεθος, μπορείτε να χρησιμοποιήσετε αυτό:

- (void)resizeImageAtPath:(NSString *)imagePath {
    // Create the image source (from path)
    CGImageSourceRef src = CGImageSourceCreateWithURL((__bridge CFURLRef) [NSURL fileURLWithPath:imagePath], NULL);

    // To create image source from UIImage, use this
    // NSData* pngData =  UIImagePNGRepresentation(image);
    // CGImageSourceRef src = CGImageSourceCreateWithData((CFDataRef)pngData, NULL);

    // Create thumbnail options
    CFDictionaryRef options = (__bridge CFDictionaryRef) @{
            (id) kCGImageSourceCreateThumbnailWithTransform : @YES,
            (id) kCGImageSourceCreateThumbnailFromImageAlways : @YES,
            (id) kCGImageSourceThumbnailMaxPixelSize : @(640)
    };
    // Generate the thumbnail
    CGImageRef thumbnail = CGImageSourceCreateThumbnailAtIndex(src, 0, options); 
    CFRelease(src);
    // Write the thumbnail at path
    CGImageWriteToFile(thumbnail, imagePath);
}

Περισσότερες λεπτομέρειες εδώ .

Καλύτερος τρόπος για να κλίμακα των εικόνων χωρίς να χάσει την αναλογία διαστάσεων (δηλαδή χωρίς τέντωμα του imgage) είναι να χρησιμοποιήσετε αυτήν τη μέθοδο:

//to scale images without changing aspect ratio
+ (UIImage *)scaleImage:(UIImage *)image toSize:(CGSize)newSize {

    float width = newSize.width;
    float height = newSize.height;

    UIGraphicsBeginImageContext(newSize);
    CGRect rect = CGRectMake(0, 0, width, height);

    float widthRatio = image.size.width / width;
    float heightRatio = image.size.height / height;
    float divisor = widthRatio > heightRatio ? widthRatio : heightRatio;

    width = image.size.width / divisor;
    height = image.size.height / divisor;

    rect.size.width  = width;
    rect.size.height = height;

    //indent in case of width or height difference
    float offset = (width - height) / 2;
    if (offset > 0) {
        rect.origin.y = offset;
    }
    else {
        rect.origin.x = -offset;
    }

    [image drawInRect: rect];

    UIImage *smallImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return smallImage;

}

Προσθέστε αυτή τη μέθοδο για την κατηγορία Utility σας, ώστε να μπορείτε να το χρησιμοποιήσετε σε όλο το έργο σας, και αποκτήστε πρόσβαση σε αυτό, όπως έτσι:

xyzImageView.image = [Utility scaleImage:yourUIImage toSize:xyzImageView.frame.size];

Αυτή η μέθοδος φροντίζει για την κλιμάκωση ενώ αναλογία διατηρώντας. Επίσης, προσθέτει παύλες στην εικόνα σε περίπτωση που το μειωθούν εικόνα έχει περισσότερο πλάτος από το ύψος (ή το αντίστροφο).

Αν έχετε τον έλεγχο του διακομιστή, θα ήθελα να συστήσω ανεπιφύλακτα την αλλαγή μεγέθους του διακομιστή εικόνες με ImageMagik . Η λήψη μεγάλων εικόνων και αλλαγή μεγέθους τους στο τηλέφωνο είναι χάσιμο πολλών πολύτιμων πόρων - εύρος ζώνης, μπαταρία και μνήμη. Όλα αυτά είναι πολύ λίγα για κινητά.

Έχω αναπτύξει μια τελική λύση για την κλιμάκωση της εικόνας στο Swift.

Μπορείτε να το χρησιμοποιήσετε για να αλλάξετε το μέγεθος της εικόνας για να γεμίσει, πτυχή συμπληρώσετε ή πτυχή ταιριάζει καθορισμένο μέγεθος.

Μπορείτε να ευθυγραμμίσετε την εικόνα στο κέντρο ή σε οποιοδήποτε από τα τέσσερα άκρα και τέσσερις γωνίες.

Και, επίσης, μπορείτε να περικόψετε επιπλέον χώρο που προστίθεται αν αναλογίες διαστάσεων της αρχικής εικόνας και το μέγεθος του στόχου δεν είναι ίσες.

enum UIImageAlignment {
    case Center, Left, Top, Right, Bottom, TopLeft, BottomRight, BottomLeft, TopRight
}

enum UIImageScaleMode {
    case Fill,
    AspectFill,
    AspectFit(UIImageAlignment)
}

extension UIImage {
    func scaleImage(width width: CGFloat? = nil, height: CGFloat? = nil, scaleMode: UIImageScaleMode = .AspectFit(.Center), trim: Bool = false) -> UIImage {
        let preWidthScale = width.map { $0 / size.width }
        let preHeightScale = height.map { $0 / size.height }
        var widthScale = preWidthScale ?? preHeightScale ?? 1
        var heightScale = preHeightScale ?? widthScale
        switch scaleMode {
        case .AspectFit(_):
            let scale = min(widthScale, heightScale)
            widthScale = scale
            heightScale = scale
        case .AspectFill:
            let scale = max(widthScale, heightScale)
            widthScale = scale
            heightScale = scale
        default:
            break
        }
        let newWidth = size.width * widthScale
        let newHeight = size.height * heightScale
        let canvasWidth = trim ? newWidth : (width ?? newWidth)
        let canvasHeight = trim ? newHeight : (height ?? newHeight)
        UIGraphicsBeginImageContextWithOptions(CGSizeMake(canvasWidth, canvasHeight), false, 0)

        var originX: CGFloat = 0
        var originY: CGFloat = 0
        switch scaleMode {
        case .AspectFit(let alignment):
            switch alignment {
            case .Center:
                originX = (canvasWidth - newWidth) / 2
                originY = (canvasHeight - newHeight) / 2
            case .Top:
                originX = (canvasWidth - newWidth) / 2
            case .Left:
                originY = (canvasHeight - newHeight) / 2
            case .Bottom:
                originX = (canvasWidth - newWidth) / 2
                originY = canvasHeight - newHeight
            case .Right:
                originX = canvasWidth - newWidth
                originY = (canvasHeight - newHeight) / 2
            case .TopLeft:
                break
            case .TopRight:
                originX = canvasWidth - newWidth
            case .BottomLeft:
                originY = canvasHeight - newHeight
            case .BottomRight:
                originX = canvasWidth - newWidth
                originY = canvasHeight - newHeight
            }
        default:
            break
        }
        self.drawInRect(CGRectMake(originX, originY, newWidth, newHeight))
        let image = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return image
    }
}

Υπάρχουν παραδείγματα της εφαρμογής του παρόντος διαλύματος κάτω.

Γκρι ορθογώνιο είναι ο στόχος ιστοσελίδα της εικόνας θα αλλάξει σε. Μπλε κύκλους σε γαλάζιο ορθογώνιο είναι η εικόνα (χρησιμοποίησα κύκλους, επειδή είναι εύκολο να δει κανείς όταν είναι σε κλίμακα χωρίς διατήρηση πτυχή). Φως πορτοκαλί χρώμα σηματοδοτεί περιοχές που θα περικοπεί αν περάσει trim: true.

Aspect ταιριάζει πριν και μετά την κλιμάκωση:

Ένα άλλο παράδειγμα της προσαρμογής πτυχή :

Aspect ταιριάζει με την κορυφαία ευθυγράμμιση:

Aspect πλήρωσης :

συμπληρώστε :

Θα χρησιμοποιηθεί για αναβάθμιση στα παραδείγματα μου, γιατί είναι πιο απλό να αποδειχθεί, αλλά λύση λειτουργεί επίσης για συρρίκνωση και στην ερώτηση.

Για συμπίεση JPEG θα πρέπει να χρησιμοποιήσετε αυτό:

let compressionQuality: CGFloat = 0.75 // adjust to change JPEG quality
if let data = UIImageJPEGRepresentation(image, compressionQuality) {
  // ...
}

Μπορείτε να ελέγξετε έξω μου ουσία με το Xcode χαρά.

Για Swift 3, ο παρακάτω κώδικας κλιμακώνει την εικόνα διατηρώντας την αναλογία διαστάσεων. Μπορείτε να διαβάσετε περισσότερα για το ImageContext στην τεκμηρίωση της Apple :

extension UIImage {
    class func resizeImage(image: UIImage, newHeight: CGFloat) -> UIImage {
        let scale = newHeight / image.size.height
        let newWidth = image.size.width * 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!
    }
}

Για να το χρησιμοποιήσετε, καλέστε resizeImage()τη μέθοδο:

UIImage.resizeImage(image: yourImageName, newHeight: yourImageNewHeight)

μπορείτε να χρησιμοποιήσετε αυτόν τον κωδικό για να αναβαθμίσουν την εικόνα στο επιθυμητό μέγεθος.

+ (UIImage *)scaleImage:(UIImage *)image toSize:(CGSize)newSize
{
    CGSize actSize = image.size;
    float scale = actSize.width/actSize.height;

    if (scale < 1) {
        newSize.height = newSize.width/scale;
    } 
    else {
        newSize.width = newSize.height*scale;
    }

    UIGraphicsBeginImageContext(newSize);
    [image drawInRect:CGRectMake(0, 0, newSize.width, newSize.height)];
    UIImage* newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return newImage;
}

func resizeImage(image: UIImage, newWidth: CGFloat) -> UIImage? {

    let scale = newWidth / image.size.width
    let newHeight = CGFloat(200.0)
    UIGraphicsBeginImageContext(CGSize(width: newWidth, height: newHeight))
    image.draw(in: CGRect(x: 0, y: 0, width: newWidth, height: newHeight))

    let newImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()

    return newImage
}

Προσθήκη στην πληθώρα των απαντήσεων εδώ, αλλά έχω πάει για μια λύση που αλλάζει μέγεθος ανάλογα με το μέγεθος του αρχείου, παρά τις διαστάσεις.

Αυτή η τόσο θα μειώσει τις διαστάσεις και την ποιότητα της εικόνας μέχρι να φτάσει δεδομένο μέγεθος σας.

func compressTo(toSizeInMB size: Double) -> UIImage? {
    let bytes = size * 1024 * 1024
    let sizeInBytes = Int(bytes)
    var needCompress:Bool = true
    var imgData:Data?
    var compressingValue:CGFloat = 1.0

    while (needCompress) {

        if let resizedImage = scaleImage(byMultiplicationFactorOf: compressingValue), let data: Data = UIImageJPEGRepresentation(resizedImage, compressingValue) {

            if data.count < sizeInBytes || compressingValue < 0.1 {
                needCompress = false
                imgData = data
            } else {
                compressingValue -= 0.1
            }
        }
    }

    if let data = imgData {
        print("Finished with compression value of: \(compressingValue)")
        return UIImage(data: data)
    }
    return nil
}

private func scaleImage(byMultiplicationFactorOf factor: CGFloat) -> UIImage? {
    let size = CGSize(width: self.size.width*factor, height: self.size.height*factor)
    UIGraphicsBeginImageContext(size)
    draw(in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
    if let newImage: UIImage = UIGraphicsGetImageFromCurrentImageContext() {
        UIGraphicsEndImageContext()
        return newImage;
    }
    return nil
}

Ακαδημαϊκών μονάδων για την κλιμάκωση του μεγέθους απάντηση

Εάν η εικόνα σας είναι στον κατάλογο έγγραφο, Προσθέστε αυτή τη διεύθυνση URL επέκτασης:

extension URL {
    func compressedImageURL(quality: CGFloat = 0.3) throws -> URL? {
        let imageData = try Data(contentsOf: self)
        debugPrint("Image file size before compression: \(imageData.count) bytes")

        let compressedURL = NSURL.fileURL(withPath: NSTemporaryDirectory() + NSUUID().uuidString + ".jpg")

        guard let actualImage = UIImage(data: imageData) else { return nil }
        guard let compressedImageData = UIImageJPEGRepresentation(actualImage, quality) else {
            return nil
        }
        debugPrint("Image file size after compression: \(compressedImageData.count) bytes")

        do {
            try compressedImageData.write(to: compressedURL)
            return compressedURL
        } catch {
            return nil
        }
    }
}

Χρήση:

guard let localImageURL = URL(string: "< LocalImagePath.jpg >") else {
    return
}

//Here you will get URL of compressed image
guard let compressedImageURL = try localImageURL.compressedImageURL() else {
    return
}

debugPrint("compressedImageURL: \(compressedImageURL.absoluteString)")

Σημείωση: - Αλλαγή <LocalImagePath.jpg> με τοπική διαδρομή jpg εικόνα σας.

- (UIImage *)resizeImage:(UIImage*)image newSize:(CGSize)newSize {
    CGRect newRect = CGRectIntegral(CGRectMake(0, 0, newSize.width, newSize.height));
    CGImageRef imageRef = image.CGImage;

    UIGraphicsBeginImageContextWithOptions(newSize, NO, 0);
    CGContextRef context = UIGraphicsGetCurrentContext();

    CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
    CGAffineTransform flipVertical = CGAffineTransformMake(1, 0, 0, -1, 0, newSize.height);

    CGContextConcatCTM(context, flipVertical);
    CGContextDrawImage(context, newRect, imageRef);

    CGImageRef newImageRef = CGBitmapContextCreateImage(context);
    UIImage *newImage = [UIImage imageWithCGImage:newImageRef];

    CGImageRelease(newImageRef);
    UIGraphicsEndImageContext();

    return newImage;
}

Ήθελα απλώς να δοθεί απάντηση στο ερώτημα για το κακάο Swift προγραμματιστές. Αυτή η συνάρτηση επιστρέφει NSImage με νέο μέγεθος. Μπορείτε να χρησιμοποιήσετε τη λειτουργία αυτή σαν αυτό.

        let sizeChangedImage = changeImageSize(image, ratio: 2)






 // changes image size

    func changeImageSize (image: NSImage, ratio: CGFloat) -> NSImage   {

    // getting the current image size
    let w = image.size.width
    let h = image.size.height

    // calculating new size
    let w_new = w / ratio 
    let h_new = h / ratio 

    // creating size constant
    let newSize = CGSizeMake(w_new ,h_new)

    //creating rect
    let rect  = NSMakeRect(0, 0, w_new, h_new)

    // creating a image context with new size
    let newImage = NSImage.init(size:newSize)



    newImage.lockFocus()

        // drawing image with new size in context
        image.drawInRect(rect)

    newImage.unlockFocus()


    return newImage

}

Δοκιμάστε το, αυτό λειτουργεί για μένα,

       CGRect rect =CGRectMake (0, 0,1200,900);
       UIGraphicsBeginImageContext( rect.size );
       [image drawInRect:rect];
       UIImage *picture1 = UIGraphicsGetImageFromCurrentImageContext();
       UIGraphicsEndImageContext();
       NSData *imageData = UIImagePNGRepresentation(picture1);
       UIImage *img=[UIImage imageWithData:imageData];
      [imageArray addObject:img];

Κατέληξα να χρησιμοποιούν καρφιά τεχνική για να δημιουργήσει μια scaleToFitWidthμέθοδο στην UIImage+Extensionsπερίπτωση αυτή είναι χρήσιμη σε όλους ...

-(UIImage *)scaleToFitWidth:(CGFloat)width
{
    CGFloat ratio = width / self.size.width;
    CGFloat height = self.size.height * ratio;

    NSLog(@"W:%f H:%f",width,height);

    UIGraphicsBeginImageContext(CGSizeMake(width, height));
    [self drawInRect:CGRectMake(0.0f,0.0f,width,height)];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return newImage;
}

τότε όποτε θέλετε

#import "UIImage+Extensions.h"

UIImage *newImage = [image scaleToFitWidth:100.0f];

Επίσης, αξίζει να σημειωθεί θα μπορούσε να κινηθεί η περαιτέρω σε μια UIView+Extensionsτάξη, αν θέλετε να καταστήσει τις εικόνες από UIView

Αν κάποιος εξακολουθεί να ψάχνει για την καλύτερη επιλογή

-(UIImage *)scaleImage:(UIImage *)image toSize:(CGSize)targetSize {


    UIImage *sourceImage = image;
    UIImage *newImage = nil;

    CGSize imageSize = sourceImage.size;
    CGFloat width = imageSize.width;
    CGFloat height = imageSize.height;

    CGFloat targetWidth = targetSize.width;
    CGFloat targetHeight = targetSize.height;

    CGFloat scaleFactor = 0.0;
    CGFloat scaledWidth = targetWidth;
    CGFloat scaledHeight = targetHeight;

    CGPoint thumbnailPoint = CGPointMake(0.0,0.0);

    if (CGSizeEqualToSize(imageSize, targetSize) == NO) {

        CGFloat widthFactor = targetWidth / width;
        CGFloat heightFactor = targetHeight / height;

        if (widthFactor < heightFactor)
            scaleFactor = widthFactor;
        else
            scaleFactor = heightFactor;

        scaledWidth  = width * scaleFactor;
        scaledHeight = height * scaleFactor;

        // center the image


        if (widthFactor < heightFactor) {
            thumbnailPoint.y = (targetHeight - scaledHeight) * 0.5;
        } else if (widthFactor > heightFactor) {
            thumbnailPoint.x = (targetWidth - scaledWidth) * 0.5;
        }
    }


    // this is actually the interesting part:

    UIGraphicsBeginImageContext(targetSize);

    CGRect thumbnailRect = CGRectZero;
    thumbnailRect.origin = thumbnailPoint;
    thumbnailRect.size.width  = scaledWidth;
    thumbnailRect.size.height = scaledHeight;

    [sourceImage drawInRect:thumbnailRect];

    newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    if(newImage == nil) NSLog(@"could not scale image");


    return newImage ;

}

Ένα πρόβλημα που μπορεί να προκύψει σε αμφιβληστροειδή οθόνες είναι ότι η κλίμακα της εικόνας ορίζεται από ImageCapture ή έτσι. Οι λειτουργίες αλλαγής μεγέθους παραπάνω δεν θα το αλλάξει αυτό. Σε αυτές τις περιπτώσεις, η αλλαγή μεγέθους θα λειτουργήσει δεν είναι σωστά.

Στον παρακάτω κώδικα, η κλίμακα έχει οριστεί σε 1 (όχι σε κλίμακα) και το επέστρεψε εικόνα έχει το μέγεθος που θα περιμένατε. Αυτό γίνεται με την UIGraphicsBeginImageContextWithOptionsκλήση.

-(UIImage *)resizeImage :(UIImage *)theImage :(CGSize)theNewSize {
    UIGraphicsBeginImageContextWithOptions(theNewSize, NO, 1.0);
    [theImage drawInRect:CGRectMake(0, 0, theNewSize.width, theNewSize.height)];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return newImage;
}

Για να αλλάξετε το μέγεθος μιας εικόνας έχω καλύτερη (γραφικά) τα αποτελέσματα από τη χρήση αυτής της λειτουργίας στη θέση του DrawInRect:

- (UIImage*) reduceImageSize:(UIImage*) pImage newwidth:(float) pWidth
{
    float lScale = pWidth / pImage.size.width;
    CGImageRef cgImage = pImage.CGImage;
    UIImage   *lResult = [UIImage imageWithCGImage:cgImage scale:lScale
                            orientation:UIImageOrientationRight];
    return lResult;
}

Ο λόγος διαστάσεων έχει ληφθεί μέριμνα για την αυτόματη