UIImage: Yeniden boyutlandır, sonra Kırp


187

Yüzümü tam anlamıyla günlerce buna dayayordum ve vahiyin tam kenarında olduğumu sürekli olarak hissetsem bile, amacımı gerçekleştiremiyorum.

Tasarımımın kavramsal aşamalarında, iPhone'un kamerasından veya kitaplığından bir görüntü almanın, Aspect Fill seçeneğine eşdeğer bir işlev kullanarak belirli bir yüksekliğe ölçeklendirmenin önemsiz bir konu olacağını düşündüm . UIImageView (tamamen kodunda), sonra da kapalı kırpmak bir geçti CGRect içinde uymayan bir şey.

Orijinal görüntüyü kameradan veya kitaplıktan almak önemsizdi. Diğer iki adımın ne kadar zor olduğu konusunda şok oldum.

Ekteki görüntü neyi başarmaya çalıştığımı gösteriyor. Birisi lütfen elimi tutacak kadar kibar olur mu? Şimdiye kadar bulduğum her kod örneği, görüntüyü parçalıyor, baş aşağı duruyor, bok gibi görünüyor, sınırlardan çıkarıyor veya başka türlü doğru çalışmıyor.


7
Bağlantı resminize bağlandı.

1
Bize şok olursa hiçbir şey Apple neden UIImagePickerController eklemedim - çok darned zor ;-)
Tim

Yanıtlar:


246

Aynı şeye ihtiyacım vardı - benim durumumda, bir kez ölçeklendirilen boyutu seçmek ve daha sonra geri kalanını genişliğe uyacak şekilde kırpmak için. (Ben manzara modunda çalışıyorum, bu yüzden portre modunda herhangi bir eksiklik fark etmemiş olabilir.) İşte benim kodum - bu UIImage bir categeory bir parçası. Kodumdaki hedef boyut her zaman cihazın tam ekran boyutuna ayarlanır.

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

1
merakla simülatörde çalışır ama cihazda ben ExecBadAccess alırım ..
Sorin Antohi

5
UIImage işlevleri iş parçacığı güvenli olmadığından, kötü exec ile ilgili sorun oluşur. Bu yüzden bazen çöküyor, bazen değil
Erik

1
Bu kod benim için harika çalıştı, ama retinada bulanıktı. Bu kodu aşağıdaki yorumla birleştirmek her şeyi mükemmelleştirdi: stackoverflow.com/questions/603907/…
MaxGabriel

23
UIGraphicsBeginImageContextWithOptions (targetSize, YES, 0.0) kullanın; retinada da güzel imajlar yaratmak için.
Borut Tomazin

1
Bu benim için Portre modunda çalışıyor, ancak manzarada değil. Yükseklik manzarada gerilir. Neden olduğu hakkında bir fikrin var mı?
Darren

77

Eski bir gönderi UIImage'ınızı yeniden boyutlandırmak için bir yöntem kodu içerir. İlgili kısım aşağıdaki gibidir:

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

   return newImage;
}

Kırpma ilerledikçe, ölçekleme için bağlama göre farklı bir boyut kullanma yöntemini değiştirirseniz, ortaya çıkan görüntünüzün bağlamın sınırlarına kırpılması gerektiğine inanıyorum.


3
Bunun neden görüntü yönlendirmesini düzelttiğine dair HİÇBİR DUYU yapmaz, ancak kamerada doğru yönü döndürmeme sorunumu giderdi originalImage. Teşekkürler.
Brenden

10
Bir retina cihazındaki bir görüntüyü yeniden boyutlandırmanın bulanık göründüğünü buldum. Netlik korumak için, ben aşağıdakilere ilk satırını modifiye: UIGraphicsBeginImageContextWithOptions(newSize, 1.0f, 0.0f);. (burada açıklanmıştır: stackoverflow.com/questions/4334233/… )
johngraham

Görüntüyü döndürür - ancak düzgün kırpmaz! Neden bu kadar çok oyu var?
Dejell

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

Bunu öneriyorum. O bir güzellik değil mi? ;)


1
Bu iyidir, eğer ilk if deyimini kaldırırsanız AspectFill işlevi görür.
RaffAl


7

Hadi bakalım. Bu mükemmel ;-)

EDIT: aşağıdaki yoruma bakın - "Belirli görüntülerle çalışmaz, başarısız: CGContextSetInterpolationQuality: geçersiz içerik 0x0 hatası"

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

1
Gerçekten çok güzel görünüyorum :) InterpolationQuality burada seviyorum
Kostiantyn Sokolinskyi

Belirli görüntülerle çalışmaz, başarısız olur: CGContextSetInterpolationQuality: geçersiz bağlam 0x0 hatası
RaffAl

6

Bu, Swift'teki Jane Sales'ın cevabının bir versiyonudur. Şerefe!

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
}

2

Brad Larson'un Kodunu değiştirdim. Görüntüyü verilen doğrultuda dolduracaktır.

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

1
Diğer iki resim, portre ve manzara ile test edildi. Bu, Boyut Doldurma işlemini gerçekleştirmiyor.
RaffAl

2

UIImage (Aspect Fill) nasıl yeniden boyutlandırılacağı ve kırpılacağı hakkında kabul edilen cevap için Xamarin.iOS sürümü aşağıdadır

    public static UIImage ScaleAndCropImage(UIImage sourceImage, SizeF targetSize)
    {
        var imageSize = sourceImage.Size;
        UIImage newImage = null;
        var width = imageSize.Width;
        var height = imageSize.Height;
        var targetWidth = targetSize.Width;
        var targetHeight = targetSize.Height;
        var scaleFactor = 0.0f;
        var scaledWidth = targetWidth;
        var scaledHeight = targetHeight;
        var thumbnailPoint = PointF.Empty;
        if (imageSize != targetSize)
        {
            var widthFactor = targetWidth / width;
            var 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.5f;
            }
            else
            {
                if (widthFactor < heightFactor)
                {
                    thumbnailPoint.X = (targetWidth - scaledWidth) * 0.5f;
                }
            }
        }
        UIGraphics.BeginImageContextWithOptions(targetSize, false, 0.0f);
        var thumbnailRect = new RectangleF(thumbnailPoint, new SizeF(scaledWidth, scaledHeight));
        sourceImage.Draw(thumbnailRect);
        newImage = UIGraphics.GetImageFromCurrentImageContext();
        if (newImage == null)
        {
            Console.WriteLine("could not scale image");
        }
        //pop the context to get back to the default
        UIGraphics.EndImageContext();

        return newImage;
    }

2

Sam Wirch'in rehberini hızlı bir şekilde dönüştürdüm ve son görüntüde çözemediğim çok hafif bir "fışkırtma" olmasına rağmen benim için iyi çalıştı.

func resizedCroppedImage(image: UIImage, newSize:CGSize) -> UIImage {
    var ratio: CGFloat = 0
    var delta: CGFloat = 0
    var offset = CGPointZero
    if image.size.width > image.size.height {
        ratio = newSize.width / image.size.width
        delta = (ratio * image.size.width) - (ratio * image.size.height)
        offset = CGPointMake(delta / 2, 0)
    } else {
        ratio = newSize.width / image.size.height
        delta = (ratio * image.size.height) - (ratio * image.size.width)
        offset = CGPointMake(0, delta / 2)
    }
    let clipRect = CGRectMake(-offset.x, -offset.y, (ratio * image.size.width) + delta, (ratio * image.size.height) + delta)
    UIGraphicsBeginImageContextWithOptions(newSize, true, 0.0)
    UIRectClip(clipRect)
    image.drawInRect(clipRect)
    let newImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return newImage
}

Herkes objektif c sürümünü istiyorsa, onun web sitesinde.


2

Evgenii Kanvets tarafından yayınlanan Swift 3'ün görüntüyü eşit bir şekilde ölçeklemediğini buldum.

İşte görüntüyü ezmeyen işlevin Swift 4 sürümü:

static func resizedCroppedImage(image: UIImage, newSize:CGSize) -> UIImage? {

    // This function returns a newImage, based on image
    // - image is scaled uniformaly to fit into a rect of size newSize
    // - if the newSize rect is of a different aspect ratio from the source image
    //     the new image is cropped to be in the center of the source image
    //     (the excess source image is removed)

    var ratio: CGFloat = 0
    var delta: CGFloat = 0
    var drawRect = CGRect()

    if newSize.width > newSize.height {

        ratio = newSize.width / image.size.width
        delta = (ratio * image.size.height) - newSize.height
        drawRect = CGRect(x: 0, y: -delta / 2, width: newSize.width, height: newSize.height + delta)

    } else {

        ratio = newSize.height / image.size.height
        delta = (ratio * image.size.width) - newSize.width
        drawRect = CGRect(x: -delta / 2, y: 0, width: newSize.width + delta, height: newSize.height)

    }

    UIGraphicsBeginImageContextWithOptions(newSize, true, 0.0)
    image.draw(in: drawRect)
    let newImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()

    return newImage
} 

Ölçekleme 1.0 ayarlamak zorunda kaldı UIGraphicsBeginImageContextWithOptionsama diğerleri mükemmel çalıştı. Teşekkürler!
maxmzd

1

Aşağıdaki basit kod benim için çalıştı.

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

Kodunuz UIImageViewnesneler için iyi çalışıyor . Ancak, bu soru UIImagenesnenin kendisini ölçeklendirmektir .
Rickster

1
scrollView = [[UIScrollView alloc] initWithFrame:CGRectMake(0.0,0.0,ScreenWidth,ScreenHeigth)];
    [scrollView setBackgroundColor:[UIColor blackColor]];
    [scrollView setDelegate:self];
    [scrollView setShowsHorizontalScrollIndicator:NO];
    [scrollView setShowsVerticalScrollIndicator:NO];
    [scrollView setMaximumZoomScale:2.0];
    image=[image scaleToSize:CGSizeMake(ScreenWidth, ScreenHeigth)];
    imageView = [[UIImageView alloc] initWithImage:image];
    UIImageView* imageViewBk = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"background.png"]];
    [self.view addSubview:imageViewBk];
    CGRect rect;
    rect.origin.x=0;
    rect.origin.y=0;
    rect.size.width = image.size.width;
    rect.size.height = image.size.height;

    [imageView setFrame:rect];

    [scrollView setContentSize:[imageView frame].size];
    [scrollView setMinimumZoomScale:[scrollView frame].size.width / [imageView frame].size.width];
    [scrollView setZoomScale:[scrollView minimumZoomScale]];
    [scrollView addSubview:imageView];

    [[self view] addSubview:scrollView];

ardından ekran resimlerinizi bununla çekebilirsiniz.

float zoomScale = 1.0 / [scrollView zoomScale];
CGRect rect;
rect.origin.x = [scrollView contentOffset].x * zoomScale;
rect.origin.y = [scrollView contentOffset].y * zoomScale;
rect.size.width = [scrollView bounds].size.width * zoomScale;
rect.size.height = [scrollView bounds].size.height * zoomScale;

CGImageRef cr = CGImageCreateWithImageInRect([[imageView image] CGImage], rect);

UIImage *cropped = [UIImage imageWithCGImage:cr];

CGImageRelease(cr);

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

İş örneğinin altında: Sol görüntü - (başlangıç ​​resmi); Ölçek x2 ile doğru görüntü

resim açıklamasını buraya girin

Görüntüyü ölçeklemek, ancak çerçevesini (orantıları) korumak istiyorsanız, yöntemi şu şekilde çağırın:

[yourImage imageScale:2.0f cropForSize:CGSizeZero];

0

Bu soru dinlenmiş gibi görünüyor, ama daha kolay anlayabildiğim (ve Swift'te yazdım) bir çözüm arayışımda, buna ulaştım (ayrıca şu adrese gönderildi: UIImage nasıl kırpılır? )


Bir en-boy oranına göre bir bölgeden kırpmak ve dış sınırlama boyutuna göre bir boyuta ölçeklendirmek istedim. İşte varyasyonum:

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

Kafa karıştırıcı bulduğum birkaç şey var, kırpma ve yeniden boyutlandırmanın ayrı kaygıları. Kırpma, drawInRect öğesine ilettiğiniz rektronun başlangıç ​​noktasıyla ve ölçeklendirme boyut bölümü tarafından gerçekleştirilir. Benim durumumda, kaynaktaki kırpma doğrultusunun boyutunu, aynı en boy oranının çıkış doğrultumla ilişkilendirmem gerekiyordu. Ölçek faktörü daha sonra çıktı / girdi olur ve bunun drawRect'e (drawInRect'e iletilmesi) uygulanması gerekir.

Bir uyarı, bu yaklaşımın, çizdiğiniz görüntünün görüntü bağlamından daha büyük olduğunu varsaymasıdır. Bunu test etmedim, ancak kırpma / yakınlaştırmayı işlemek için bu kodu kullanabileceğinizi, ancak açıkça yukarıda belirtilen ölçek parametresi olarak scale parametresini tanımladığınızı düşünüyorum. Varsayılan olarak, UIKit ekran çözünürlüğüne göre bir çarpan uygular.

Son olarak, bu UIKit yaklaşımının CoreGraphics / Quartz ve Core Image yaklaşımlarından daha yüksek olduğu ve görüntü yönelimi sorunlarını ele aldığı görülmektedir. Ayrıca, bu yazıda göre, ImageIO'dan sonra oldukça hızlı olduğunu belirtmek gerekir: http://nshipster.com/image-resizing/


0

Hızlı sürüm:

    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
}

1
Güzel küçük fonksiyon ama eminim ki bu görüntü sadece belirli bir boyuta uzanır, en boy oranı ve kırpma tutmaz ...
William T.

Evet haklısın, bu sadece görüntüyü paritküler bir boyuta yönlendirir.
Roman Barzyczak

0

İşte Sam Wirch'in William T tarafından yayınlanan hızlı bir kılavuzun Swift 3 versiyonu.

extension UIImage {

    static func resizedCroppedImage(image: UIImage, newSize:CGSize) -> UIImage? {
        var ratio: CGFloat = 0
        var delta: CGFloat = 0
        var offset = CGPoint.zero

        if image.size.width > image.size.height {
            ratio = newSize.width / image.size.width
            delta = (ratio * image.size.width) - (ratio * image.size.height)
            offset = CGPoint(x: delta / 2, y: 0)
        } else {
            ratio = newSize.width / image.size.height
            delta = (ratio * image.size.height) - (ratio * image.size.width)
            offset = CGPoint(x: 0, y: delta / 2)
        }

        let clipRect = CGRect(x: -offset.x, y: -offset.y, width: (ratio * image.size.width) + delta, height: (ratio * image.size.height) + delta)
        UIGraphicsBeginImageContextWithOptions(newSize, true, 0.0)
        UIRectClip(clipRect)
        image.draw(in: clipRect)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()

        return newImage
    }

}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.