आकार बदलने के लिए / 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);
}

अधिक जानकारी के लिए यहाँ ।

(इमेज अधिक समय दिए बिना यानी) पहलू अनुपात खोता जा रहा है इस विधि का उपयोग करने के लिए बिना छवियों पैमाने पर करने के लिए सबसे अच्छा तरीका:

//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;

}

अपने उपयोगिता वर्ग के लिए इस विधि जोड़ें ताकि आप उसे अपनी परियोजना भर में उपयोग कर सकते हैं, और इसलिए की तरह इसे का उपयोग:

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

इस विधि जबकि पहलू अनुपात को बनाए रखने स्केलिंग का ख्याल रखता है। यह भी मामले में छवि के लिए इंडेंट कहते हैं घटाया छवि ऊँचाई (या इसके विपरीत) की तुलना में अधिक चौड़ाई है।

आप सर्वर पर नियंत्रण है, तो मैं दृढ़ता से साथ छवियों सर्वर साइड का आकार बदलने की सिफारिश करेंगे ImageMagik । बैंडविड्थ, बैटरी और स्मृति - बड़े चित्र डाउनलोड करने और फोन पर उन्हें आकार बदलने कई कीमती संसाधनों की बर्बादी है। जिनमें से सभी फोन पर दुर्लभ हैं।

मैं स्विफ्ट में छवि स्केलिंग के लिए एक अंतिम समाधान का विकास किया।

आप छवि का आकार बदलने को भरने के लिए उपयोग कर सकते हैं, पहलू को भरने या पहलू निर्दिष्ट आकार फिट।

आप केंद्र या चार किनारों और चारों कोनों में से किसी के लिए छवि संरेखित कर सकते हैं।

और यह भी आप अतिरिक्त जगह जो यदि मूल छवि और लक्ष्य आकार के पहलू अनुपात बराबर नहीं हैं जोड़ा जाता है ट्रिम कर सकते हैं।

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।

पहलू फिट से पहले और स्केलिंग बाद:

का एक और उदाहरण पहलू फिट :

पहलू फिट शीर्ष संरेखण के साथ:

पहलू को भरने :

भरें :

मैं अपने उदाहरण में आकार बढ़ाए जाने के लिए इस्तेमाल किया है क्योंकि यह प्रदर्शित करने के लिए आसान है, लेकिन समाधान भी प्रश्न में के रूप में downscaling के लिए काम करता है।

JPEG संपीड़न के लिए आप इस का उपयोग करना चाहिए:

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

तुम मेरे की जांच कर सकते सार Xcode खेल का मैदान के साथ।

स्विफ्ट 3 के लिए, नीचे दिए गए कोड छवि पहलू अनुपात रखने मापता है। आप में ImageContext के बारे में अधिक पढ़ सकते हैं एप्पल के प्रलेखन :

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
}

के लिए क्रेडिट आकार जवाब से स्केलिंग

यदि आप छवि दस्तावेज़ निर्देशिका में है, इस जोड़े यूआरएल विस्तार:

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> अपने स्थानीय जेपीजी छवि पथ के साथ।

- (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;
}

मैं सिर्फ कोको स्विफ्ट प्रोग्रामर के लिए इस सवाल का जवाब देना चाहता था। यह समारोह नई आकार के साथ 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];

मैं Brads तकनीक का उपयोग कर एक बनाने के लिए समाप्त हो गया 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;
}

पहलू अनुपात स्वचालित रूप से करने के लिए ध्यान रखा जाता है