iphone - UIImage: आकार बदलें, फिर फसल




ios image-processing (10)

मैं सचमुच दिनों के लिए इस में अपना चेहरा झुका रहा हूं और भले ही मैं लगातार महसूस करता हूं कि मैं प्रकाशन के किनारे पर सही हूं, मैं बस अपना लक्ष्य प्राप्त नहीं कर सकता।

मैंने सोचा, मेरे डिजाइन के वैचारिक चरणों में समय से पहले, यह आईफोन के कैमरे या लाइब्रेरी से एक छवि को पकड़ने के लिए एक मामूली मामला होगा, इसे एस्पेक्ट फिल विकल्प के समतुल्य फ़ंक्शन का उपयोग करके, निर्दिष्ट ऊंचाई पर स्केल करें UIImageView (पूरी तरह से कोड में), और तब किसी भी चीज को फसल करें जो पास किए गए CGRect के भीतर फिट नहीं हुआ है।

कैमरा या पुस्तकालय से मूल छवि प्राप्त करना, मामूली था। मैं चौंक गया हूं कि दूसरे दो कदम कितने मुश्किल साबित हुए हैं।

संलग्न छवि दिखाती है कि मैं क्या हासिल करने की कोशिश कर रहा हूं। क्या कोई मेरे हाथ पकड़ने के लिए बहुत दयालु होगा? मुझे लगता है कि प्रत्येक कोड उदाहरण अब तक छवि को तोड़ने, ऊपर की ओर, बकवास की तरह दिखता है, सीमा से बाहर खींचता है, या अन्यथा सही ढंग से काम नहीं करता है।


एक पुरानी पोस्ट में आपके UIImage का आकार बदलने के लिए विधि शामिल है। प्रासंगिक भाग इस प्रकार है:

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

   return newImage;
}

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


ऐसा लगता है कि यह सवाल बाकी है, लेकिन एक समाधान के लिए मेरी खोज में जिसे मैं आसानी से समझ सकता हूं (और स्विफ्ट में लिखा गया), मैं इस पर पहुंचा (यहां पोस्ट किया गया: यूआईएममेज कैसे फसल करें? )

मैं एक पक्ष अनुपात के आधार पर एक क्षेत्र से फसल करने में सक्षम होना चाहता था, और एक बाहरी सीमा सीमा के आधार पर आकार के पैमाने पर। यहां मेरी विविधता है:

import AVFoundation
import ImageIO

class Image {

    class func crop(image:UIImage, crop source:CGRect, aspect:CGSize, outputExtent:CGSize) -> UIImage {

        let sourceRect = AVMakeRectWithAspectRatioInsideRect(aspect, source)
        let targetRect = AVMakeRectWithAspectRatioInsideRect(aspect, CGRect(origin: CGPointZero, size: outputExtent))

        let opaque = true, deviceScale:CGFloat = 0.0 // use scale of device's main screen
        UIGraphicsBeginImageContextWithOptions(targetRect.size, opaque, deviceScale)

        let scale = max(
            targetRect.size.width / sourceRect.size.width,
            targetRect.size.height / sourceRect.size.height)

        let drawRect = CGRect(origin: -sourceRect.origin * scale, size: image.size * scale)
        image.drawInRect(drawRect)

        let scaledImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()

        return scaledImage
    }
}

कुछ ऐसी चीजें हैं जिन्हें मैंने उलझन में पाया, फसल और आकार बदलने की अलग-अलग चिंताओं। फसल को रेक्ट की उत्पत्ति के साथ संभाला जाता है जिसे आप drawInRect में पास करते हैं, और स्केलिंग आकार के हिस्से से संभाला जाता है। मेरे मामले में, मुझे स्रोत पर क्रॉपिंग रेक्ट के आकार को समान पहलू अनुपात के आउटपुट रेक्ट से संबंधित करने की आवश्यकता थी। स्केल फैक्टर तब उत्पादन / इनपुट होता है, और इसे drawRect (drawInRect को पास किया गया) पर लागू करने की आवश्यकता होती है।

एक चेतावनी यह है कि यह दृष्टिकोण प्रभावी ढंग से मानता है कि आप जिस छवि को चित्रित कर रहे हैं वह छवि संदर्भ से बड़ी है। मैंने इसका परीक्षण नहीं किया है, लेकिन मुझे लगता है कि आप क्रॉपिंग / ज़ूमिंग को संभालने के लिए इस कोड का उपयोग कर सकते हैं, लेकिन उपरोक्त स्केल पैरामीटर होने के लिए स्केल पैरामीटर को स्पष्ट रूप से परिभाषित कर सकते हैं। डिफ़ॉल्ट रूप से, UIKit स्क्रीन रिज़ॉल्यूशन के आधार पर एक गुणक लागू करता है।

अंत में, यह ध्यान दिया जाना चाहिए कि यह UIKit दृष्टिकोण कोरग्राफिक्स / क्वार्ट्ज और कोर छवि दृष्टिकोण से उच्च स्तर है, और छवि अभिविन्यास के मुद्दों को संभालने लगता है। यह भी उल्लेखनीय है कि यह बहुत तेज है, इमेजियो के लिए दूसरा, इस पोस्ट के अनुसार यहां: http://nshipster.com/image-resizing/


निम्नलिखित सरल कोड मेरे लिए काम किया।

[imageView setContentMode:UIViewContentModeScaleAspectFill];
[imageView setClipsToBounds:YES];

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

@implementation UIImage (Extras)

#pragma mark -
#pragma mark Scale and crop image

- (UIImage*)imageByScalingAndCroppingForSize:(CGSize)targetSize
{
    UIImage *sourceImage = self;
    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; // scale to fit height
        }
        else
        {
            scaleFactor = heightFactor; // scale to fit width
        }

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

    UIGraphicsBeginImageContext(targetSize); // this will crop

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

    [sourceImage drawInRect:thumbnailRect];

    newImage = UIGraphicsGetImageFromCurrentImageContext();

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

    //pop the context to get back to the default
    UIGraphicsEndImageContext();

    return newImage;
}

मैंने ब्रैड लार्सन के कोड को संशोधित किया। यह चित्रित आय में छवि को भर देगा।

-(UIImage*) scaleAndCropToSize:(CGSize)newSize;
{
    float ratio = self.size.width / self.size.height;

    UIGraphicsBeginImageContext(newSize);

    if (ratio > 1) {
        CGFloat newWidth = ratio * newSize.width;
        CGFloat newHeight = newSize.height;
        CGFloat leftMargin = (newWidth - newHeight) / 2;
        [self drawInRect:CGRectMake(-leftMargin, 0, newWidth, newHeight)];
    }
    else {
        CGFloat newWidth = newSize.width;
        CGFloat newHeight = newSize.height / ratio;
        CGFloat topMargin = (newHeight - newWidth) / 2;
        [self drawInRect:CGRectMake(0, -topMargin, newSize.width, newSize.height/ratio)];
    }

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

    return newImage;
}

यह स्विफ्ट में जेन सेल्स के जवाब का एक संस्करण है। चीयर्स!

public func resizeImage(image: UIImage, size: CGSize) -> UIImage? {
    var returnImage: UIImage?

    var scaleFactor: CGFloat = 1.0
    var scaledWidth = size.width
    var scaledHeight = size.height
    var thumbnailPoint = CGPointMake(0, 0)

    if !CGSizeEqualToSize(image.size, size) {
        let widthFactor = size.width / image.size.width
        let heightFactor = size.height / image.size.height

        if widthFactor > heightFactor {
            scaleFactor = widthFactor
        } else {
            scaleFactor = heightFactor
        }

        scaledWidth = image.size.width * scaleFactor
        scaledHeight = image.size.height * scaleFactor

        if widthFactor > heightFactor {
            thumbnailPoint.y = (size.height - scaledHeight) * 0.5
        } else if widthFactor < heightFactor {
            thumbnailPoint.x = (size.width - scaledWidth) * 0.5
        }
    }

    UIGraphicsBeginImageContextWithOptions(size, true, 0)

    var thumbnailRect = CGRectZero
    thumbnailRect.origin = thumbnailPoint
    thumbnailRect.size.width = scaledWidth
    thumbnailRect.size.height = scaledHeight

    image.drawInRect(thumbnailRect)
    returnImage = UIGraphicsGetImageFromCurrentImageContext()

    UIGraphicsEndImageContext()

    return returnImage
}

स्विफ्ट संस्करण:

    static func imageWithImage(image:UIImage, newSize:CGSize) ->UIImage {
    UIGraphicsBeginImageContextWithOptions(newSize, true, UIScreen.mainScreen().scale);
    image.drawInRect(CGRectMake(0, 0, newSize.width, newSize.height))

    let newImage = UIGraphicsGetImageFromCurrentImageContext();

    UIGraphicsEndImageContext();
    return newImage
}

हेयर यू गो। यह एकदम सही है ;-)

संपादित करें: नीचे टिप्पणी देखें - "कुछ छवियों के साथ काम नहीं करता है, इसमें विफल रहता है: CGContextSetInterpolationQuality: अमान्य संदर्भ 0x0 त्रुटि"

// Resizes the image according to the given content mode, taking into account the image's orientation
- (UIImage *)resizedImageWithContentMode:(UIViewContentMode)contentMode imageToScale:(UIImage*)imageToScale bounds:(CGSize)bounds interpolationQuality:(CGInterpolationQuality)quality {
    //Get the size we want to scale it to
    CGFloat horizontalRatio = bounds.width / imageToScale.size.width;
    CGFloat verticalRatio = bounds.height / imageToScale.size.height;
    CGFloat ratio;

    switch (contentMode) {
        case UIViewContentModeScaleAspectFill:
            ratio = MAX(horizontalRatio, verticalRatio);
            break;

        case UIViewContentModeScaleAspectFit:
            ratio = MIN(horizontalRatio, verticalRatio);
            break;

        default:
            [NSException raise:NSInvalidArgumentException format:@"Unsupported content mode: %d", contentMode];
    }

    //...and here it is
    CGSize newSize = CGSizeMake(imageToScale.size.width * ratio, imageToScale.size.height * ratio);


    //start scaling it
    CGRect newRect = CGRectIntegral(CGRectMake(0, 0, newSize.width, newSize.height));
    CGImageRef imageRef = imageToScale.CGImage;
    CGContextRef bitmap = CGBitmapContextCreate(NULL,
                                                newRect.size.width,
                                                newRect.size.height,
                                                CGImageGetBitsPerComponent(imageRef),
                                                0,
                                                CGImageGetColorSpace(imageRef),
                                                CGImageGetBitmapInfo(imageRef));

    CGContextSetInterpolationQuality(bitmap, quality);

    // Draw into the context; this scales the image
    CGContextDrawImage(bitmap, newRect, imageRef);

    // Get the resized image from the context and a UIImage
    CGImageRef newImageRef = CGBitmapContextCreateImage(bitmap);
    UIImage *newImage = [UIImage imageWithCGImage:newImageRef];

    // Clean up
    CGContextRelease(bitmap);
    CGImageRelease(newImageRef);

    return newImage;
}

+ (UIImage *)scaleImage:(UIImage *)image toSize:(CGSize)targetSize {
    //If scaleFactor is not touched, no scaling will occur      
    CGFloat scaleFactor = 1.0;

    //Deciding which factor to use to scale the image (factor = targetSize / imageSize)
    if (image.size.width > targetSize.width || image.size.height > targetSize.height)
        if (!((scaleFactor = (targetSize.width / image.size.width)) > (targetSize.height / image.size.height))) //scale to fit width, or
            scaleFactor = targetSize.height / image.size.height; // scale to fit heigth.

    UIGraphicsBeginImageContext(targetSize); 

    //Creating the rect where the scaled image is drawn in
    CGRect rect = CGRectMake((targetSize.width - image.size.width * scaleFactor) / 2,
                             (targetSize.height -  image.size.height * scaleFactor) / 2,
                             image.size.width * scaleFactor, image.size.height * scaleFactor);

    //Draw the image into the rect
    [image drawInRect:rect];

    //Saving the image, ending image context
    UIImage *scaledImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return scaledImage;
}

मैं इसे प्रस्तावित करता हूं। क्या वह एक सुंदरता नहीं है? ;)


- (UIImage*)imageScale:(CGFloat)scaleFactor cropForSize:(CGSize)targetSize
{
    targetSize = !targetSize.width?self.size:targetSize;
    UIGraphicsBeginImageContext(targetSize); // this will crop

    CGRect thumbnailRect = CGRectZero;

    thumbnailRect.size.width  = targetSize.width*scaleFactor;
    thumbnailRect.size.height = targetSize.height*scaleFactor;
    CGFloat xOffset = (targetSize.width- thumbnailRect.size.width)/2;
    CGFloat yOffset = (targetSize.height- thumbnailRect.size.height)/2;
    thumbnailRect.origin = CGPointMake(xOffset,yOffset);

    [self drawInRect:thumbnailRect];

    UIImage *newImage  = UIGraphicsGetImageFromCurrentImageContext();

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

    UIGraphicsEndImageContext();

    return newImage;
}

काम के उदाहरण के नीचे: बाएं छवि - (मूल छवि); स्केल x2 के साथ सही छवि

यदि आप छवि को स्केल करना चाहते हैं लेकिन इसके फ्रेम (अनुपात) को बनाए रखना चाहते हैं, तो इस तरह से कॉल विधि:

[yourImage imageScale:2.0f cropForSize:CGSizeZero];




core-graphics