UIImage का आकार बदलने का सबसे सरल तरीका?


397

अपने iPhone ऐप में, मैं कैमरे के साथ एक तस्वीर लेता हूं, फिर मैं इसे 290 * 390 पिक्सेल का आकार बदलना चाहता हूं। मैं इस विधि का उपयोग छवि का आकार बदलने के लिए कर रहा था:

UIImage *newImage = [image _imageScaledToSize:CGSizeMake(290, 390)
                         interpolationQuality:1];    

यह पूरी तरह से काम करता है, लेकिन यह एक अनिर्धारित फ़ंक्शन है, इसलिए मैं इसे अब iPhone OS4 के साथ उपयोग नहीं कर सकता।

तो ... UIImage का आकार बदलने का सबसे सरल तरीका क्या है?


2019 में इसे करने का तरीका, nshipster.com/image-resizing
dengST30

जवाबों:


772

सबसे सरल तरीका यह है कि अपने फ्रेम को सेट करें UIImageViewऔर contentModeआकार बदलने वाले विकल्पों में से एक को सेट करें।

या आप इस उपयोगिता विधि का उपयोग कर सकते हैं, यदि आपको वास्तव में एक छवि का आकार बदलने की आवश्यकता है:

+ (UIImage *)imageWithImage:(UIImage *)image scaledToSize:(CGSize)newSize {
    //UIGraphicsBeginImageContext(newSize);
    // In next line, pass 0.0 to use the current device's pixel scaling factor (and thus account for Retina resolution).
    // Pass 1.0 to force exact pixel size.
    UIGraphicsBeginImageContextWithOptions(newSize, NO, 0.0);
    [image drawInRect:CGRectMake(0, 0, newSize.width, newSize.height)];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();    
    UIGraphicsEndImageContext();
    return newImage;
}

उदाहरण उपयोग:

#import "MYUtil.h"

UIImage *myIcon = [MYUtil imageWithImage:myUIImageInstance scaledToSize:CGSizeMake(20, 20)];

11
मैं यहां परिणाम को बरकरार नहीं रखूंगा। newImageपहले से ही ऑटोरेलिज्ड हो जाएगा, और यह उस विधि तक होना चाहिए जिसने इसे बनाए रखने के लिए इसे बुलाया है या नहीं। यह तरीका केवल मेमोरी बग के लिए भीख माँग रहा initहै क्योंकि विधि नाम का हिस्सा नहीं है। मैं एक ऑटोरेल्ड ऑब्जेक्ट को वापस करने के लिए इस तरह नाम की एक विधि की उम्मीद करूंगा।
एलेक्स वेन

मान्य बिंदु, और संपादित। मैं बस सावधानी बरतता हूँ कि मेरा कोड जो इस कोड का उपयोग करता है, वह अतिरिक्त अवलंबन के बिना कहीं और मॉलोक त्रुटियों को उत्पन्न करता है, जो स्पष्ट रूप से किसी तरह मेरी गलती है :-)।
पॉल लिंच

26
IOS 4.0 के रूप में , UIGraphics * फ़ंक्शन सभी थ्रेड-सुरक्षित हैं।
बीजे होमर

3
@ पाओल लिंच: ध्यान रखें कि यह परिवर्तन मूल पोस्ट के मिशन को तोड़ता है: किसी सटीक पिक्सेल आकार में एक छवि का आकार कैसे बदलें ( बिंदु आकार के विपरीत )।
निकोलाई रुहे

8
सीमा @NikolaiRuhe की वजह से संघर्ष करने वालों के लिए, आप इसे कॉल करने के लिए 1.0 के बजाय 1.0 पास करके एक सटीक पिक्सेल आकार के लिए मजबूर कर सकते हैंUIGraphicsBeginImageContextWithOptions
डैनी

84

यहाँ पॉल लिंच के जवाब का एक स्विफ्ट संस्करण है

func imageWithImage(image:UIImage, scaledToSize newSize:CGSize) -> UIImage{
    UIGraphicsBeginImageContextWithOptions(newSize, false, 0.0);
    image.drawInRect(CGRectMake(0, 0, newSize.width, newSize.height))
    let newImage:UIImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return newImage
}

और विस्तार के रूप में:

public extension UIImage {
    func copy(newSize: CGSize, retina: Bool = true) -> UIImage? {
        // In next line, pass 0 to use the current device's pixel scaling factor (and thus account for Retina resolution).
        // Pass 1 to force exact pixel size.
        UIGraphicsBeginImageContextWithOptions(
            /* size: */ newSize,
            /* opaque: */ false,
            /* scale: */ retina ? 0 : 1
        )
        defer { UIGraphicsEndImageContext() }

        self.draw(in: CGRect(origin: .zero, size: newSize))
        return UIGraphicsGetImageFromCurrentImageContext()
    }
}

2
अभी उल्लेख किया गया है कि, iOS में, आपका newSize 2x से 3x होगा, डिवाइस के आधार पर 3x
SCT A.Suk

6
UIGraphicsBeginImageContextWithOptions (newSize, false, image.scale); सभी उपकरणों के लिए
phnmnn

ध्यान दें कि यह अंतर्निहित CGImage (कम से कम iOS 12.1 में) का आकार परिवर्तन नहीं करता है। जो प्रश्न के आधार पर ठीक है, लेकिन अगर आप छवि को लिख रहे हैं, तो आपको cgImage का उपयोग करना होगा, और आपको मूल छवि मिल जाएगी।
Prewett

72

IOS 10+ समाधान के लिए उचित स्विफ्ट 3.0 : सिंटैक्स का उपयोग करना और बंद करना :ImageRenderer

func imageWith(newSize: CGSize) -> UIImage {
    let renderer = UIGraphicsImageRenderer(size: newSize)
    let image = renderer.image { _ in
        self.draw(in: CGRect.init(origin: CGPoint.zero, size: newSize))
    }

    return image.withRenderingMode(self.renderingMode)
}

और यहाँ उद्देश्य-सी संस्करण है:

@implementation UIImage (ResizeCategory)
- (UIImage *)imageWithSize:(CGSize)newSize
{
    UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:newSize];
    UIImage *image = [renderer imageWithActions:^(UIGraphicsImageRendererContext*_Nonnull myContext) {
        [self drawInRect:(CGRect) {.origin = CGPointZero, .size = newSize}];
    }];
    return [image imageWithRenderingMode:self.renderingMode];
}
@end

1
बहुत सुरुचिपूर्ण समाधान, यह स्वीकृत उत्तर होना चाहिए!
सराहना की

2
यह सुरुचिपूर्ण से बेहतर है, यह सही है। Apple का एपी डॉक्स UIGraphicsRenderer का उपयोग करने के लिए नए कोड की सलाह देता है जैसा कि यह कोड करता है। धन्यवाद
पॉल ब्रूनो

1
@appsunited सवाल लगभग 8 साल पुराना है। और यह विधि केवल iOS10 + के लिए काम करती है जैसा कि कहा गया है।

क्लिपबोर्ड में नई छवि ऑब्जेक्ट की प्रतिलिपि बनाते समय यह मेरे लिए एक सफेद ब्लॉक बनाता है। यह वास्तव में छवि दृश्य का आकार नहीं बदल रहा है?
ओलिवर डिक्सन

1
यह कार्य 0 ऊँचाई और 0 चौड़ाई की छवि लौटाता है, ऊँचाई 9000 ऊँचाई और 9000 चौड़ाई है।
कृष्ण कुमार

31

ट्रेवर हॉवर्ड की कुछ UIImage श्रेणियां हैं जो बहुत अच्छी तरह से आकार बदलती हैं। यदि और कुछ नहीं तो आप उदाहरण के रूप में कोड का उपयोग कर सकते हैं।

नोट: iOS 5.1 के रूप में, यह उत्तर शायद अमान्य है। नीचे टिप्पणी देखें।


2
मुझे कुछ छवियों का भी आकार बदलने की आवश्यकता थी, और मैंने पहले UIImage में ट्रेवर के परिवर्धन की कोशिश की, लेकिन PNG के कुछ अजीब कीड़े मिले (अल्फा चैनल के बारे में कुछ)। इस सवाल का स्वीकृत जवाब हालांकि अच्छी तरह से काम किया।
सोरिग

1
यह अब मान्य नहीं है (कम से कम iOS5.1 के साथ
Jann

@ जान, पोस्ट के नीचे कमिट्स पर एक नज़र
वाइकिंगोजगुंडो

@ अगर आप टिप्पणियों में सुझाए गए फ़िक्सेस का पालन करते हैं, तो "मैट कहते हैं: 22 नवंबर, 2011 को शाम 5:39 बजे" पर जाएं क्योंकि वह कलर्सपेरेफ़ (हॉर्सशो 7 के समान समाधान के विपरीत) जारी करता है।
बेन फ्लिन

1
@sanmai इनमें से किसी भी आकार बदलने के तरीकों का उपयोग करके छवियों को इसके तेज नेस को खो देता है। क्या तीक्ष्णता प्राप्त करने का कोई तरीका है
vamsi575kg

31

स्विफ्ट 4 और आईओएस 10+ के लिए एक अधिक कॉम्पैक्ट संस्करण:

extension UIImage {
    func resized(to size: CGSize) -> UIImage {
        return UIGraphicsImageRenderer(size: size).image { _ in
            draw(in: CGRect(origin: .zero, size: size))
        }
    }
}

उपयोग:

let resizedImage = image.resized(to: CGSize(width: 50, height: 50))

26

मैंने इसे भी देखा है (जो कि मैं UIButtonsबटन के resizeफिट होने के बाद से सामान्य और चयनित स्थिति के लिए उपयोग करता हूं )। इसका श्रेय मूल लेखक को जाता है।

सबसे पहले एक .h और .m फाइल को खाली करें UIImageResizing.hऔरUIImageResizing.m

// Put this in UIImageResizing.h
@interface UIImage (Resize)
- (UIImage*)scaleToSize:(CGSize)size;
@end

// Put this in UIImageResizing.m
@implementation UIImage (Resize)

- (UIImage*)scaleToSize:(CGSize)size {
UIGraphicsBeginImageContext(size);

CGContextRef context = UIGraphicsGetCurrentContext();
CGContextTranslateCTM(context, 0.0, size.height);
CGContextScaleCTM(context, 1.0, -1.0);

CGContextDrawImage(context, CGRectMake(0.0f, 0.0f, size.width, size.height), self.CGImage);

UIImage* scaledImage = UIGraphicsGetImageFromCurrentImageContext();

UIGraphicsEndImageContext();

return scaledImage;
}

@end

उस .h फ़ाइल को उस फ़ाइल में शामिल करें जो आप .m फ़ाइल में फ़ंक्शन का उपयोग करने जा रहे हैं और फिर इसे इस तरह से कॉल करें:

UIImage* image = [UIImage imageNamed:@"largeImage.png"];
UIImage* smallImage = [image scaleToSize:CGSizeMake(100.0f,100.0f)];

यह छवि अभिविन्यास पर प्रतिलिपि नहीं करता है।
केविन

20

पॉल के कोड में यह सुधार आपको एक iPhone पर एक रेटिना डिस्प्ले के साथ एक तेज उच्च रेस छवि देगा। अन्यथा जब नीचे स्केलिंग यह धुंधली है।

+ (UIImage *)imageWithImage:(UIImage *)image scaledToSize:(CGSize)newSize {
if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)]) {
    if ([[UIScreen mainScreen] scale] == 2.0) {
        UIGraphicsBeginImageContextWithOptions(newSize, YES, 2.0);
    } else {
        UIGraphicsBeginImageContext(newSize);
    }
} else {
    UIGraphicsBeginImageContext(newSize);
}
[image drawInRect:CGRectMake(0, 0, newSize.width, newSize.height)];
UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();    
UIGraphicsEndImageContext();
return newImage;
}

13
सिर्फ FYI करें, आपके द्वारा किए गए परिवर्तन अनावश्यक हैं, क्योंकि स्केल के लिए 0.0 के मान की आपूर्ति UIGraphicsBeginImageContextWithOptionsस्वचालित रूप से मुख्य स्क्रीन के पैमाने (iOS 3.2 के रूप में) का उपयोग करेगी।
एंड्रयू आर।

16

यहाँ एक आसान तरीका है:

    UIImage * image = [UIImage imageNamed:@"image"];
    CGSize sacleSize = CGSizeMake(10, 10);
    UIGraphicsBeginImageContextWithOptions(sacleSize, NO, 0.0);
    [image drawInRect:CGRectMake(0, 0, sacleSize.width, sacleSize.height)];
    UIImage * resizedImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

resizedImage एक नई छवि है।


16

खिंचाव भराव, पहलू भरण और पहलू फ़िट के लिए स्विफ्ट समाधान

extension UIImage {
    enum ContentMode {
        case contentFill
        case contentAspectFill
        case contentAspectFit
    }

    func resize(withSize size: CGSize, contentMode: ContentMode = .contentAspectFill) -> UIImage? {
        let aspectWidth = size.width / self.size.width
        let aspectHeight = size.height / self.size.height

        switch contentMode {
        case .contentFill:
            return resize(withSize: size)
        case .contentAspectFit:
            let aspectRatio = min(aspectWidth, aspectHeight)
            return resize(withSize: CGSize(width: self.size.width * aspectRatio, height: self.size.height * aspectRatio))
        case .contentAspectFill:
            let aspectRatio = max(aspectWidth, aspectHeight)
            return resize(withSize: CGSize(width: self.size.width * aspectRatio, height: self.size.height * aspectRatio))
        }
    }

    private func resize(withSize size: CGSize) -> UIImage? {
        UIGraphicsBeginImageContextWithOptions(size, false, self.scale)
        defer { UIGraphicsEndImageContext() }
        draw(in: CGRect(x: 0.0, y: 0.0, width: size.width, height: size.height))
        return UIGraphicsGetImageFromCurrentImageContext()
    }
}

और उपयोग करने के लिए आप निम्न कार्य कर सकते हैं:

let image = UIImage(named: "image.png")!
let newImage = image.resize(withSize: CGSize(width: 200, height: 150), contentMode: .contentAspectFill)

उसके मूल समाधान के लिए abdullahselek का धन्यवाद।


15

यहाँ ऊपर iWasRobbed द्वारा लिखित श्रेणी का संशोधन है। यह मूल छवि के पहलू अनुपात को विकृत करने के बजाय रखता है।

- (UIImage*)scaleToSizeKeepAspect:(CGSize)size {
    UIGraphicsBeginImageContext(size);

    CGFloat ws = size.width/self.size.width;
    CGFloat hs = size.height/self.size.height;

    if (ws > hs) {
        ws = hs/ws;
        hs = 1.0;
    } else {
        hs = ws/hs;
        ws = 1.0;
    }

    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextTranslateCTM(context, 0.0, size.height);
    CGContextScaleCTM(context, 1.0, -1.0);

    CGContextDrawImage(context, CGRectMake(size.width/2-(size.width*ws)/2,
        size.height/2-(size.height*hs)/2, size.width*ws,
        size.height*hs), self.CGImage);

    UIImage* scaledImage = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();

    return scaledImage;
}

11

यदि आप किसी छवि को छोटा चाहते हैं और सटीक आकार की परवाह नहीं करते हैं:

+ (UIImage *)imageWithImage:(UIImage *)image scaledToScale:(CGFloat)scale
{
    UIGraphicsBeginImageContextWithOptions(self.size, YES, scale);
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
    [self drawInRect:CGRectMake(0, 0, self.size.width, self.size.height)];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return newImage;
}

0.25f8MP कैमरा से 612 इमेज द्वारा आपको 816 का स्केल सेट करना होगा।

यहां उन लोगों के लिए एक श्रेणी UIImage + Scale है जिन्हें एक की आवश्यकता है।


10

इतना जटिल क्यों? मुझे लगता है कि सिस्टम API का उपयोग करके वही परिणाम प्राप्त कर सकते हैं:

UIImage *largeImage;
CGFloat ratio = 0.4; // you want to get a new image that is 40% the size of large image.
UIImage *newImage = [UIImage imageWithCGImage:largeImage.CGImage
                                        scale:1/ratio
                                  orientation:largeImage.imageOrientation];
// notice the second argument, it is 1/ratio, not ratio.

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


क्योंकि स्केल (%) पिक्सल्स (w / h) के समान नहीं है।

पैमाना बड़ा होना चाहिए। बड़े पैमाने पर। 1 / अनुपात का अनुपात नहीं।
मारीअनार्नी

9

यह स्विफ्ट 3 और स्विफ्ट 4 के साथ संगत एक UIImage एक्सटेंशन है जो एक आस्पेक्ट रेशियो के साथ इमेज को साइज़ देता है

extension UIImage {

    func scaledImage(withSize size: CGSize) -> UIImage {
        UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
        defer { UIGraphicsEndImageContext() }
        draw(in: CGRect(x: 0.0, y: 0.0, width: size.width, height: size.height))
        return UIGraphicsGetImageFromCurrentImageContext()!
    }

    func scaleImageToFitSize(size: CGSize) -> UIImage {
        let aspect = self.size.width / self.size.height
        if size.width / aspect <= size.height {
            return scaledImage(withSize: CGSize(width: size.width, height: size.width / aspect))
        } else {
            return scaledImage(withSize: CGSize(width: size.height * aspect, height: size.height))
        }
    }

}

उदाहरण उपयोग

let image = UIImage(named: "apple")
let scaledImage = image.scaleImageToFitSize(size: CGSize(width: 45.0, height: 45.0))

मैं फ़ंक्शन का नाम scaledImage(with size:)या करने की सिफारिश करूंगा scaledWithSize(_:)UIGraphicsGetImageFromCurrentImageContextवास्तव में भी नहीं लौट सकते nil, इसलिए !भी काम करेंगे। तुम भी सृजन को सरल कर सकते हैं CGRect(origin: .zero, size: size)
सुल्तान

8

मुझे Apple के अपने उदाहरणों में UIImage के लिए एक श्रेणी मिली, जो एक ही चाल है। यहां लिंक दिया गया है: https://developer.apple.com/library/ios/samplecode/sc2273/Listings/AirDropSample_UIImage_Resize_m.html

आपको बस कॉल बदलनी होगी:

UIGraphicsBeginImageContextWithOptions(newSize, YES, 2.0);

में imageWithImage:scaledToSize:inRect:साथ:

UIGraphicsBeginImageContextWithOptions(newSize, NO, 2.0);

छवि में अल्फा चैनल पर विचार करने के लिए।


6
 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
}

अपने कोड के साथ जाने के लिए कुछ वर्णनात्मक पाठ जोड़ना एक अच्छा विचार है।
GMchris

6

मेरे साथी ज़ैमरियन के लिए, यहाँ @Paul लिंच उत्तर का एक Xamarin.iOS C # संस्करण है।

private UIImage ResizeImage(UIImage image, CGSize newSize) 
{
    UIGraphics.BeginImageContextWithOptions(newSize, false, 0.0f);
    image.Draw(new CGRect(0, 0, newSize.Width, newSize.Height));
    UIImage newImage = UIGraphics.GetImageFromCurrentImageContext();
    UIGraphics.EndImageContext();
    return newImage;
}

5

यदि आप एक UIImage का एक थंबनेल बनाना चाहते हैं (आनुपातिक आकार बदलने या शायद कुछ फसल शामिल है), UIImage + Resize श्रेणी देखें जो आपको संक्षिप्त, ImageMagick जैसे सिंटैक्स का उपयोग करने की अनुमति देता है:

UIImage* squareImage       = [image resizedImageByMagick: @"320x320#"];

5

[cf क्रिस] वांछित आकार का आकार बदलने के लिए :

UIImage *after = [UIImage imageWithCGImage:before.CGImage
                                     scale:CGImageGetHeight(before.CGImage)/DESIREDHEIGHT
                               orientation:UIImageOrientationUp];

या, समकक्ष, स्थानापन्न CGImageGetWidth(...)/DESIREDWIDTH


ध्यान दें कि छवि डेटा खुद को आकार नहीं देता है, लेकिन एक स्केल फैक्टर लागू किया जाता है जिसका अर्थ है कि छवि स्मृति में समान आकार की है।
इंक्रेडिबल डेस

5

Rogerio Chaves एक तेजी से विस्तार के रूप में जवाब देता है

func scaledTo(size: CGSize) -> UIImage{
    UIGraphicsBeginImageContextWithOptions(size, false, 0.0);
    self.draw(in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
    let newImage:UIImage = UIGraphicsGetImageFromCurrentImageContext()!
    UIGraphicsEndImageContext()
    return newImage
}

और बोनस भी

func scaledTo(height: CGFloat) -> UIImage{
    let width = height*self.size.width/self.size.height
    return scaledTo(size: CGSize(width: width, height: height))
}

5

विफलता के विकल्प के साथ 3.0 स्विफ्ट (त्रुटि के मामले में मूल छवि लौटाता है):

func resize(image: UIImage, toSize size: CGSize) -> UIImage{
    UIGraphicsBeginImageContextWithOptions(size,false,1.0)
    image.draw(in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
    if let resizedImage = UIGraphicsGetImageFromCurrentImageContext() {
        UIGraphicsEndImageContext()
        return resizedImage
    }
    UIGraphicsEndImageContext()
    return image
}

5

(स्विफ्ट 4 संगत) आईओएस 10+ और आईओएस <10 समाधान ( UIGraphicsImageRendererयदि संभव हो तो उपयोग करना, UIGraphicsGetImageFromCurrentImageContextअन्यथा)

/// Resizes an image
///
/// - Parameter newSize: New size
/// - Returns: Resized image
func scaled(to newSize: CGSize) -> UIImage {
    let rect = CGRect(origin: .zero, size: newSize)

    if #available(iOS 10, *) {
        let renderer = UIGraphicsImageRenderer(size: newSize)
        return renderer.image { _ in
            self.draw(in: rect)
        }
    } else {
        UIGraphicsBeginImageContextWithOptions(newSize, false, 0.0)
        self.draw(in: rect)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return newImage!
    }
}

5

स्ट्रेचिंग इमेज के बिना प्रभावी दृष्टिकोण स्विफ्ट 4

// Method to resize image
func resize(image: UIImage, toScaleSize:CGSize) -> UIImage {
                UIGraphicsBeginImageContextWithOptions(toScaleSize, true, image.scale)
                        image.draw(in: CGRect(x: 0, y: 0, width: toScaleSize.width, height: toScaleSize.height))
                        let scaledImage = UIGraphicsGetImageFromCurrentImageContext()
                        UIGraphicsEndImageContext()
                        return scaledImage!
                }

// कॉल विधि

    let resizedImage = self.resize(image: UIImage(named: "YourImageName")!, toScaleSize: CGSize(width: 290, height: 390))

3

@ पाओल लिंच का जवाब बहुत अच्छा है, लेकिन यह छवि अनुपात को बदल देगा। यदि आप छवि अनुपात को बदलना नहीं चाहते हैं, और फिर भी नई छवि को नए आकार के लिए फिट करना चाहते हैं, तो यह प्रयास करें।

+ (UIImage *)imageWithImage:(UIImage *)image scaledToSize:(CGSize)newSize {

// calculate a new size which ratio is same to original image
CGFloat ratioW = image.size.width / newSize.width;
CGFloat ratioH = image.size.height / newSize.height;

CGFloat ratio = image.size.width / image.size.height;

CGSize showSize = CGSizeZero;
if (ratioW > 1 && ratioH > 1) { 

    if (ratioW > ratioH) { 
        showSize.width = newSize.width;
        showSize.height = showSize.width / ratio;
    } else {
        showSize.height = newSize.height;
        showSize.width = showSize.height * ratio;
    }

} else if (ratioW > 1) {

    showSize.width = showSize.width;
    showSize.height = showSize.width / ratio;

} else if (ratioH > 1) {

    showSize.height = showSize.height;
    showSize.width = showSize.height * ratio;

}

//UIGraphicsBeginImageContext(newSize);
// In next line, pass 0.0 to use the current device's pixel scaling factor (and thus account for Retina resolution).
// Pass 1.0 to force exact pixel size.
UIGraphicsBeginImageContextWithOptions(showSize, NO, 0.0);
[image drawInRect:CGRectMake(0, 0, showSize.width, showSize.height)];
UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
UIGraphicsEndImageContext();
return newImage;}

3

इस एक्सटेंशन का उपयोग करें

extension UIImage {
    public func resize(size:CGSize, completionHandler:(resizedImage:UIImage, data:NSData?)->()) {
        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), { () -> Void in
            let newSize:CGSize = size
            let rect = CGRectMake(0, 0, newSize.width, newSize.height)
            UIGraphicsBeginImageContextWithOptions(newSize, false, 1.0)
            self.drawInRect(rect)
            let newImage = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()
            let imageData = UIImageJPEGRepresentation(newImage, 0.5)
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                completionHandler(resizedImage: newImage, data:imageData)
            })
        })
    }
}

2

स्विफ्ट 2.0:

let image = UIImage(named: "imageName")
let newSize = CGSize(width: 10, height: 10)

UIGraphicsBeginImageContextWithOptions(newSize, false, 0.0)
image?.drawInRect(CGRectMake(0, 0, newSize.width, newSize.height))
let imageResized = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()

2

यहाँ मेरा कुछ-क्रिया-स्विफ्ट कोड है

func scaleImage(image:UIImage,  toSize:CGSize) -> UIImage {
    UIGraphicsBeginImageContextWithOptions(toSize, false, 0.0);

    let aspectRatioAwareSize = self.aspectRatioAwareSize(image.size, boxSize: toSize, useLetterBox: false)


    let leftMargin = (toSize.width - aspectRatioAwareSize.width) * 0.5
    let topMargin = (toSize.height - aspectRatioAwareSize.height) * 0.5


    image.drawInRect(CGRectMake(leftMargin, topMargin, aspectRatioAwareSize.width , aspectRatioAwareSize.height))
    let retVal = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return retVal
}

func aspectRatioAwareSize(imageSize: CGSize, boxSize: CGSize, useLetterBox: Bool) -> CGSize {
    // aspect ratio aware size
    // http://stackoverflow.com/a/6565988/8047
    let imageWidth = imageSize.width
    let imageHeight = imageSize.height
    let containerWidth = boxSize.width
    let containerHeight = boxSize.height

    let imageAspectRatio = imageWidth/imageHeight
    let containerAspectRatio = containerWidth/containerHeight

    let retVal : CGSize
    // use the else at your own risk: it seems to work, but I don't know 
    // the math
    if (useLetterBox) {
        retVal = containerAspectRatio > imageAspectRatio ? CGSizeMake(imageWidth * containerHeight / imageHeight, containerHeight) : CGSizeMake(containerWidth, imageHeight * containerWidth / imageWidth)
    } else {
        retVal = containerAspectRatio < imageAspectRatio ? CGSizeMake(imageWidth * containerHeight / imageHeight, containerHeight) : CGSizeMake(containerWidth, imageHeight * containerWidth / imageWidth)
    }

    return retVal
}

1
इससे मेरा समय बच गया। धन्यवाद!
क्वाई नगुयेन

उपयोगी, लेकिन अजीब तरह से काम करने के बाद और वापस आने की गतिविधियों के बाद, यहां देखें plz: stackoverflow.com/questions/30978685/…
वह Yifei 何

कृपया ध्यान दें: आप फ़ंक्शन में एक पूर्व शर्त ( guard) जोड़ना चाह सकते हैं ताकि aspectRatioAwareSizeयह शून्य अपवाद से भाग न जाए यदि छवि पैरामीटर या बॉक्स के लिए इनपुट पैरामीटर हैं या नहीं हैंCGSize.zero
pkluz

@pkluz यह एक अच्छा सुझाव है, लेकिन आपको उन सभी फ़ंक्शन की आवश्यकता होगी, मुझे लगता है, क्योंकि प्रत्येक चर एक और पंक्ति का विभाजक है ... मैं इसे स्पष्टता के लिए छोड़ने जा रहा हूं। उत्पादन के लिए या जीथुब के लिए एक पुस्तकालय, आप इसे गोमांस करना चाह सकते हैं ... एक गार्ड से अधिक, मुझे चिंता है कि फ़ंक्शन छोटे चर नामों का उपयोग करता है जो बहुत कुछ नहीं कहते हैं। मैं शायद पहले ठीक कर दूंगा, और फिर अन्य चीजों के लिए गार्ड जोड़ दूंगा, और फिर यूनिट टेस्ट जोड़ूंगा।
दान रोसेनस्टार्क

2

स्विफ्ट 4 उत्तर:

func scaleDown(image: UIImage, withSize: CGSize) -> UIImage {
    let scale = UIScreen.main.scale
    UIGraphicsBeginImageContextWithOptions(withSize, false, scale)
    image.draw(in: CGRect(x: 0, y: 0, width: withSize.width, height: withSize.height))
    let newImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return newImage!
}

वास्तविक स्केल सेट करने की आवश्यकता नहीं है:The scale factor to apply to the bitmap. If you specify a value of 0.0, the scale factor is set to the scale factor of the device’s main screen.
nathan

1

मुझे पता चला है कि यह जवाब खोजना मुश्किल है कि आप अपने स्विफ्ट 3 प्रोजेक्ट में आउट-ऑफ-द बॉक्स का उपयोग कर सकते हैं । अन्य उत्तरों की मुख्य समस्या यह है कि वे छवि के अल्फा-चैनल का सम्मान नहीं करते हैं। यहां वह तकनीक है जो मैं अपनी परियोजनाओं में उपयोग कर रहा हूं।

extension UIImage {

    func scaledToFit(toSize newSize: CGSize) -> UIImage {
        if (size.width < newSize.width && size.height < newSize.height) {
            return copy() as! UIImage
        }

        let widthScale = newSize.width / size.width
        let heightScale = newSize.height / size.height

        let scaleFactor = widthScale < heightScale ? widthScale : heightScale
        let scaledSize = CGSize(width: size.width * scaleFactor, height: size.height * scaleFactor)

        return self.scaled(toSize: scaledSize, in: CGRect(x: 0.0, y: 0.0, width: scaledSize.width, height: scaledSize.height))
    }

    func scaled(toSize newSize: CGSize, in rect: CGRect) -> UIImage {
        if UIScreen.main.scale == 2.0 {
            UIGraphicsBeginImageContextWithOptions(newSize, !hasAlphaChannel, 2.0)
        }
        else {
            UIGraphicsBeginImageContext(newSize)
        }

        draw(in: rect)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()

        return newImage ?? UIImage()
    }

    var hasAlphaChannel: Bool {
        guard let alpha = cgImage?.alphaInfo else {
            return false
        }
        return alpha == CGImageAlphaInfo.first ||
            alpha == CGImageAlphaInfo.last ||
            alpha == CGImageAlphaInfo.premultipliedFirst ||
            alpha == CGImageAlphaInfo.premultipliedLast
    }
}

उपयोग का उदाहरण:

override func viewDidLoad() {
    super.viewDidLoad()

    let size = CGSize(width: 14.0, height: 14.0)
    if let image = UIImage(named: "barbell")?.scaledToFit(toSize: size) {
        let imageView = UIImageView(image: image)
        imageView.center = CGPoint(x: 100, y: 100)
        view.addSubview(imageView)
    }
}

यह कोड अल्फा चैनल के साथ और बिना छवियों के लिए समर्थन के साथ Apple के विस्तार को फिर से लिखना है ।

एक और पढ़ने के रूप में, मैं अलग-अलग छवि के आकार बदलने की तकनीकों के लिए इस लेख की जांच करने की सलाह देता हूं । वर्तमान दृष्टिकोण सभ्य प्रदर्शन प्रदान करता है, यह उच्च-स्तरीय एपीआई और समझने में आसान है। जब तक आपको यह पता नहीं चलता है कि आपके चित्र में एक अड़चन है, तब तक मैं उससे चिपके रहने की सलाह देता हूं।


1

इस अनुपात का उपयोग करें, यदि आपको केवल पहलू अनुपात के साथ चौड़ाई / ऊँचाई का आकार बदलने की आवश्यकता है।

extension UIImage {
    func resize(to size: CGSize) -> UIImage {
        return UIGraphicsImageRenderer(size: size).image { _ in
            draw(in: CGRect(origin: .zero, size: size))
        }
    }
    func resize(width: CGFloat) -> UIImage {
        return resize(to: CGSize(width: width, height: width / (size.width / size.height)))
    }
    func resize(height: CGFloat) -> UIImage {
        return resize(to: CGSize(width: height * (size.width / size.height), height: height))
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.