Tôi đã có một số mã thay đổi kích thước hình ảnh để tôi có thể lấy một phần nhỏ của trung tâm hình ảnh - Tôi sử dụng mã này để lấy UIImagevà trả về một hình ảnh nhỏ, vuông của hình ảnh, tương tự như hình ảnh trong chế độ xem album của ứng dụng Ảnh. (Tôi biết rằng tôi có thể sử dụng a UIImageViewvà điều chỉnh chế độ cắt để đạt được kết quả tương tự, nhưng những hình ảnh này đôi khi được hiển thị trong UIWebViews).

Tôi đã bắt đầu nhận thấy một số sự cố trong mã này và tôi hơi bối rối. Tôi đã có hai lý thuyết khác nhau và tôi tự hỏi liệu một trong hai là dựa trên cơ sở.

Lý thuyết 1) Tôi đạt được việc cắt xén bằng cách vẽ vào bối cảnh hình ảnh ngoài màn hình với kích thước mục tiêu của tôi. Vì tôi muốn phần trung tâm của hình ảnh, tôi đặt CGRectđối số được chuyển drawInRectsang một cái gì đó lớn hơn giới hạn của bối cảnh hình ảnh của tôi. Tôi đã hy vọng đây là Kosher, nhưng thay vào đó tôi đang cố gắng vẽ lên những ký ức khác mà tôi không nên chạm vào?

Lý thuyết 2) Tôi đang làm tất cả những điều này trong một chủ đề nền. Tôi biết có những phần của UIKit bị giới hạn trong luồng chính. Tôi đã giả định / hy vọng rằng việc vẽ lên một khung nhìn ngoài màn hình không phải là một trong số đó. Liệu tôi có sai?

(Ồ, làm thế nào tôi bỏ lỡ NSImage's drawInRect:fromRect:operation:fraction:phương pháp.)

Cập nhật 2014-05-28: Tôi đã viết điều này khi iOS 3 trở đi là điều mới mẻ, tôi chắc chắn có nhiều cách tốt hơn để làm điều này ngay bây giờ, có thể được tích hợp sẵn. Như nhiều người đã đề cập, phương pháp này không tính đến việc xoay vòng; đọc một số câu trả lời bổ sung và lan truyền một số tình yêu thượng lưu xung quanh để giữ cho câu trả lời cho câu hỏi này hữu ích cho mọi người.

Phản hồi ban đầu:

Tôi sẽ sao chép / dán câu trả lời của mình cho cùng một câu hỏi ở nơi khác:

Không có một phương thức lớp đơn giản để làm điều này, nhưng có một chức năng mà bạn có thể sử dụng để có được kết quả mong muốn: CGImageCreateWithImageInRect(CGImageRef, CGRect)sẽ giúp bạn giải quyết.

Đây là một ví dụ ngắn sử dụng nó:

CGImageRef imageRef = CGImageCreateWithImageInRect([largeImage CGImage], cropRect);
// or use the UIImage wherever you like
[UIImageView setImage:[UIImage imageWithCGImage:imageRef]]; 
CGImageRelease(imageRef);

Để cắt hình ảnh võng mạc trong khi vẫn giữ nguyên tỷ lệ và hướng, hãy sử dụng phương pháp sau trong danh mục UIImage (iOS 4.0 trở lên):

- (UIImage *)crop:(CGRect)rect {
    if (self.scale > 1.0f) {
        rect = CGRectMake(rect.origin.x * self.scale,
                          rect.origin.y * self.scale,
                          rect.size.width * self.scale,
                          rect.size.height * self.scale);
    }

    CGImageRef imageRef = CGImageCreateWithImageInRect(self.CGImage, rect);
    UIImage *result = [UIImage imageWithCGImage:imageRef scale:self.scale orientation:self.imageOrientation];
    CGImageRelease(imageRef);
    return result;
}

Bạn có thể tạo một thể loại UIImage và sử dụng nó bất cứ nơi nào bạn cần. Dựa trên phản hồi và bình luận của HitScans dưới đây.

@implementation UIImage (Crop)

- (UIImage *)crop:(CGRect)rect {

    rect = CGRectMake(rect.origin.x*self.scale, 
                      rect.origin.y*self.scale, 
                      rect.size.width*self.scale, 
                      rect.size.height*self.scale);       

    CGImageRef imageRef = CGImageCreateWithImageInRect([self CGImage], rect);
    UIImage *result = [UIImage imageWithCGImage:imageRef 
                                          scale:self.scale 
                                    orientation:self.imageOrientation]; 
    CGImageRelease(imageRef);
    return result;
}

@end

Bạn có thể sử dụng nó theo cách này:

UIImage *imageToCrop = <yourImageToCrop>;
CGRect cropRect = <areaYouWantToCrop>;   

//for example
//CGRectMake(0, 40, 320, 100);

UIImage *croppedImage = [imageToCrop crop:cropRect];

Phiên bản Swift 3

func cropImage(imageToCrop:UIImage, toRect rect:CGRect) -> UIImage{
    
    let imageRef:CGImage = imageToCrop.cgImage!.cropping(to: rect)!
    let cropped:UIImage = UIImage(cgImage:imageRef)
    return cropped
}


let imageTop:UIImage  = UIImage(named:"one.jpg")! // add validation

với sự trợ giúp của chức năng cầu nối này CGRectMake-> CGRect(tín dụng cho câu trả lời này được trả lời bởi @rob mayoff):

 func CGRectMake(_ x: CGFloat, _ y: CGFloat, _ width: CGFloat, _ height: CGFloat) -> CGRect {
    return CGRect(x: x, y: y, width: width, height: height)
}

Cách sử dụng là:

if var image:UIImage  = UIImage(named:"one.jpg"){
   let  croppedImage = cropImage(imageToCrop: image, toRect: CGRectMake(
        image.size.width/4,
        0,
        image.size.width/2,
        image.size.height)
    )
}

Đầu ra:

Đây là triển khai cây trồng UIImage của tôi tuân theo thuộc tính imageOrientation. Tất cả các định hướng đã được kiểm tra kỹ lưỡng.

inline double rad(double deg)
{
    return deg / 180.0 * M_PI;
}

UIImage* UIImageCrop(UIImage* img, CGRect rect)
{
    CGAffineTransform rectTransform;
    switch (img.imageOrientation)
    {
        case UIImageOrientationLeft:
            rectTransform = CGAffineTransformTranslate(CGAffineTransformMakeRotation(rad(90)), 0, -img.size.height);
            break;
        case UIImageOrientationRight:
            rectTransform = CGAffineTransformTranslate(CGAffineTransformMakeRotation(rad(-90)), -img.size.width, 0);
            break;
        case UIImageOrientationDown:
            rectTransform = CGAffineTransformTranslate(CGAffineTransformMakeRotation(rad(-180)), -img.size.width, -img.size.height);
            break;
        default:
            rectTransform = CGAffineTransformIdentity;
    };
    rectTransform = CGAffineTransformScale(rectTransform, img.scale, img.scale);

    CGImageRef imageRef = CGImageCreateWithImageInRect([img CGImage], CGRectApplyAffineTransform(rect, rectTransform));
    UIImage *result = [UIImage imageWithCGImage:imageRef scale:img.scale orientation:img.imageOrientation];
    CGImageRelease(imageRef);
    return result;
}

Cảnh giác: tất cả các câu trả lời này giả định một CGImageđối tượng hình ảnh được hỗ trợ.

image.CGImagecó thể trả về nil, nếu UIImageđược hỗ trợ bởi a CIImage, đó sẽ là trường hợp nếu bạn tạo hình ảnh này bằng cách sử dụng a CIFilter.

Trong trường hợp đó, bạn có thể phải vẽ hình ảnh trong một bối cảnh mới và trả lại hình ảnh đó ( chậm ).

UIImage* crop(UIImage *image, rect) {
    UIGraphicsBeginImageContextWithOptions(rect.size, false, [image scale]);
    [image drawAtPoint:CGPointMake(-rect.origin.x, -rect.origin.y)];
    cropped_image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return cropped_image;
}

Không có câu trả lời nào ở đây xử lý tất cả các vấn đề về tỷ lệ và xoay chính xác 100%. Đây là tổng hợp của tất cả mọi thứ cho đến nay, cập nhật kể từ iOS7 / 8. Nó có nghĩa là được đưa vào như một phương pháp trong một thể loại trên UIImage.

- (UIImage *)croppedImageInRect:(CGRect)rect
{
    double (^rad)(double) = ^(double deg) {
        return deg / 180.0 * M_PI;
    };

    CGAffineTransform rectTransform;
    switch (self.imageOrientation) {
        case UIImageOrientationLeft:
            rectTransform = CGAffineTransformTranslate(CGAffineTransformMakeRotation(rad(90)), 0, -self.size.height);
            break;
        case UIImageOrientationRight:
            rectTransform = CGAffineTransformTranslate(CGAffineTransformMakeRotation(rad(-90)), -self.size.width, 0);
            break;
        case UIImageOrientationDown:
            rectTransform = CGAffineTransformTranslate(CGAffineTransformMakeRotation(rad(-180)), -self.size.width, -self.size.height);
            break;
        default:
            rectTransform = CGAffineTransformIdentity;
    };
    rectTransform = CGAffineTransformScale(rectTransform, self.scale, self.scale);

    CGImageRef imageRef = CGImageCreateWithImageInRect([self CGImage], CGRectApplyAffineTransform(rect, rectTransform));
    UIImage *result = [UIImage imageWithCGImage:imageRef scale:self.scale orientation:self.imageOrientation];
    CGImageRelease(imageRef);

    return result;
}

Phiên bản Swift của awolfcâu trả lời, hoạt động cho tôi:

public extension UIImage {
    func croppedImage(inRect rect: CGRect) -> UIImage {
        let rad: (Double) -> CGFloat = { deg in
            return CGFloat(deg / 180.0 * .pi)
        }
        var rectTransform: CGAffineTransform
        switch imageOrientation {
        case .left:
            let rotation = CGAffineTransform(rotationAngle: rad(90))
            rectTransform = rotation.translatedBy(x: 0, y: -size.height)
        case .right:
            let rotation = CGAffineTransform(rotationAngle: rad(-90))
            rectTransform = rotation.translatedBy(x: -size.width, y: 0)
        case .down:
            let rotation = CGAffineTransform(rotationAngle: rad(-180))
            rectTransform = rotation.translatedBy(x: -size.width, y: -size.height)
        default:
            rectTransform = .identity
        }
        rectTransform = rectTransform.scaledBy(x: scale, y: scale)
        let transformedRect = rect.applying(rectTransform)
        let imageRef = cgImage!.cropping(to: transformedRect)!
        let result = UIImage(cgImage: imageRef, scale: scale, orientation: imageOrientation)
        return result
    }
}

CGSize size = [originalImage size];
int padding = 20;
int pictureSize = 300;
int startCroppingPosition = 100;
if (size.height > size.width) {
    pictureSize = size.width - (2.0 * padding);
    startCroppingPosition = (size.height - pictureSize) / 2.0; 
} else {
    pictureSize = size.height - (2.0 * padding);
    startCroppingPosition = (size.width - pictureSize) / 2.0;
}
// WTF: Don't forget that the CGImageCreateWithImageInRect believes that 
// the image is 180 rotated, so x and y are inverted, same for height and width.
CGRect cropRect = CGRectMake(startCroppingPosition, padding, pictureSize, pictureSize);
CGImageRef imageRef = CGImageCreateWithImageInRect([originalImage CGImage], cropRect);
UIImage *newImage = [UIImage imageWithCGImage:imageRef scale:1.0 orientation:originalImage.imageOrientation];
[m_photoView setImage:newImage];
CGImageRelease(imageRef);

Hầu hết các câu trả lời tôi thấy chỉ liên quan đến vị trí (0, 0) cho (x, y). Ok đó là một trường hợp nhưng tôi muốn hoạt động cắt xén của tôi được tập trung. Điều khiến tôi mất một thời gian để tìm ra là dòng sau bình luận WTF.

Hãy xem trường hợp của một hình ảnh được chụp với hướng dọc:

1. Chiều cao hình ảnh gốc cao hơn chiều rộng của nó (Woo, không có gì ngạc nhiên cho đến nay!)
2. Hình ảnh mà phương thức CGImageCreateWithImageInRect tưởng tượng trong thế giới riêng của nó không thực sự là một bức chân dung mà là một cảnh quan (Đó cũng là lý do tại sao nếu bạn không sử dụng đối số định hướng trong hàm tạo của imageWithCGImage, nó sẽ hiển thị dưới dạng xoay 180).
3. Vì vậy, bạn nên tưởng tượng rằng đó là một phong cảnh, vị trí (0, 0) là góc trên cùng bên phải của hình ảnh.

Hy vọng nó có ý nghĩa! Nếu không, hãy thử các giá trị khác nhau mà bạn sẽ thấy rằng logic được đảo ngược khi chọn đúng x, y, chiều rộng và chiều cao cho cropRect của bạn.

nhanh chóng3

extension UIImage {
    func crop(rect: CGRect) -> UIImage? {
        var scaledRect = rect
        scaledRect.origin.x *= scale
        scaledRect.origin.y *= scale
        scaledRect.size.width *= scale
        scaledRect.size.height *= scale
        guard let imageRef: CGImage = cgImage?.cropping(to: scaledRect) else {
            return nil
        }
        return UIImage(cgImage: imageRef, scale: scale, orientation: imageOrientation)
    }
}

Mở rộng Swift

extension UIImage {
    func crop(var rect: CGRect) -> UIImage {
        rect.origin.x*=self.scale
        rect.origin.y*=self.scale
        rect.size.width*=self.scale
        rect.size.height*=self.scale

        let imageRef = CGImageCreateWithImageInRect(self.CGImage, rect)
        let image = UIImage(CGImage: imageRef, scale: self.scale, orientation: self.imageOrientation)!
        return image
    }
}

Giải pháp tốt nhất để cắt xén một UIImage trong Swift , về độ chính xác, tỷ lệ pixel ...:

private func squareCropImageToSideLength(let sourceImage: UIImage,
    let sideLength: CGFloat) -> UIImage {
        // input size comes from image
        let inputSize: CGSize = sourceImage.size

        // round up side length to avoid fractional output size
        let sideLength: CGFloat = ceil(sideLength)

        // output size has sideLength for both dimensions
        let outputSize: CGSize = CGSizeMake(sideLength, sideLength)

        // calculate scale so that smaller dimension fits sideLength
        let scale: CGFloat = max(sideLength / inputSize.width,
            sideLength / inputSize.height)

        // scaling the image with this scale results in this output size
        let scaledInputSize: CGSize = CGSizeMake(inputSize.width * scale,
            inputSize.height * scale)

        // determine point in center of "canvas"
        let center: CGPoint = CGPointMake(outputSize.width/2.0,
            outputSize.height/2.0)

        // calculate drawing rect relative to output Size
        let outputRect: CGRect = CGRectMake(center.x - scaledInputSize.width/2.0,
            center.y - scaledInputSize.height/2.0,
            scaledInputSize.width,
            scaledInputSize.height)

        // begin a new bitmap context, scale 0 takes display scale
        UIGraphicsBeginImageContextWithOptions(outputSize, true, 0)

        // optional: set the interpolation quality.
        // For this you need to grab the underlying CGContext
        let ctx: CGContextRef = UIGraphicsGetCurrentContext()
        CGContextSetInterpolationQuality(ctx, kCGInterpolationHigh)

        // draw the source image into the calculated rect
        sourceImage.drawInRect(outputRect)

        // create new image from bitmap context
        let outImage: UIImage = UIGraphicsGetImageFromCurrentImageContext()

        // clean up
        UIGraphicsEndImageContext()

        // pass back new image
        return outImage
}

Hướng dẫn sử dụng để gọi chức năng này:

let image: UIImage = UIImage(named: "Image.jpg")!
let squareImage: UIImage = self.squareCropImageToSideLength(image, sideLength: 320)
self.myUIImageView.image = squareImage

Lưu ý: nguồn cảm hứng mã nguồn ban đầu được viết trong Objective-C đã được tìm thấy trên blog "Cocoanetic".

Đoạn mã dưới đây có thể giúp đỡ.

import UIKit

extension UIImage {
    func cropImage(toRect rect: CGRect) -> UIImage? {
        if let imageRef = self.cgImage?.cropping(to: rect) {
            return UIImage(cgImage: imageRef)
        }
        return nil
    }
}

Trông hơi lạ nhưng hoạt động tuyệt vời và xem xét định hướng hình ảnh:

var image:UIImage = ...

let img = CIImage(image: image)!.imageByCroppingToRect(rect)
image = UIImage(CIImage: img, scale: 1, orientation: image.imageOrientation)

Swift 5:

extension UIImage {
    func cropped(rect: CGRect) -> UIImage? {
        guard let cgImage = cgImage else { return nil }

        UIGraphicsBeginImageContextWithOptions(rect.size, false, 0)
        let context = UIGraphicsGetCurrentContext()

        context?.translateBy(x: 0.0, y: self.size.height)
        context?.scaleBy(x: 1.0, y: -1.0)
        context?.draw(cgImage, in: CGRect(x: rect.minX, y: rect.minY, width: self.size.width, height: self.size.height), byTiling: false)


        let croppedImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()

        return croppedImage
    }
}

- (UIImage *)getSubImage:(CGRect) rect{
    CGImageRef subImageRef = CGImageCreateWithImageInRect(self.CGImage, rect);
    CGRect smallBounds = CGRectMake(rect.origin.x, rect.origin.y, CGImageGetWidth(subImageRef), CGImageGetHeight(subImageRef));

    UIGraphicsBeginImageContext(smallBounds.size);
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextDrawImage(context, smallBounds, subImageRef);
    UIImage* smallImg = [UIImage imageWithCGImage:subImageRef];
    UIGraphicsEndImageContext();

    return smallImg;
}

 (UIImage *)squareImageWithImage:(UIImage *)image scaledToSize:(CGSize)newSize {
    double ratio;
    double delta;
    CGPoint offset;

    //make a new square size, that is the resized imaged width
    CGSize sz = CGSizeMake(newSize.width, newSize.width);

    //figure out if the picture is landscape or portrait, then
    //calculate scale factor and offset
    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);
    }

    //make the final clipping rect based on the calculated values
    CGRect clipRect = CGRectMake(-offset.x, -offset.y,
                                 (ratio * image.size.width) + delta,
                                 (ratio * image.size.height) + delta);


    //start a new context, with scale factor 0.0 so retina displays get
    //high quality image
    if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)]) {
        UIGraphicsBeginImageContextWithOptions(sz, YES, 0.0);
    } else {
        UIGraphicsBeginImageContext(sz);
    }
    UIRectClip(clipRect);
    [image drawInRect:clipRect];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    return newImage;
}

Trên iOS9.2SDK, tôi sử dụng phương pháp bên dưới để chuyển đổi khung hình từ UIView sang UIImage

-(UIImage *)getNeedImageFrom:(UIImage*)image cropRect:(CGRect)rect
{
  CGSize cropSize = rect.size;
  CGFloat widthScale = image.size.width/self.imageViewOriginal.bounds.size.width;
  CGFloat heightScale = image.size.height/self.imageViewOriginal.bounds.size.height;
  cropSize = CGSizeMake(rect.size.width*widthScale, 
              rect.size.height*heightScale);
  CGPoint pointCrop = CGPointMake(rect.origin.x*widthScale,
             rect.origin.y*heightScale);
  rect = CGRectMake(pointCrop.x, pointCrop.y, cropSize.width, cropSize.height);
  CGImageRef subImage = CGImageCreateWithImageInRect(image.CGImage, rect);
  UIImage *croppedImage = [UIImage imageWithCGImage:subImage];
  CGImageRelease(subImage);

  return croppedImage;
}

Cập nhật Swift 2.0 ( CIImagetương thích)

Mở rộng ra câu trả lời của Maxim nhưng cũng hoạt động nếu hình ảnh của bạn cũng CIImagedựa.

public extension UIImage {
    func imageByCroppingToRect(rect: CGRect) -> UIImage? {
        if let image = CGImageCreateWithImageInRect(self.CGImage, rect) {
            return UIImage(CGImage: image)
        } else if let image = (self.CIImage)?.imageByCroppingToRect(rect) {
            return UIImage(CIImage: image)
        }
       return nil
   }
}

Đây là phiên bản Swift 3 được cập nhật dựa trên câu trả lời của Noodles

func cropping(to rect: CGRect) -> UIImage? {

    if let cgCrop = cgImage?.cropping(to: rect) {
        return UIImage(cgImage: cgCrop)
    }
    else if let ciCrop = ciImage?.cropping(to: rect) {
        return UIImage(ciImage: ciCrop)
    }

    return nil
}

Theo dõi câu trả lời của @Arne. Tôi chỉ sửa chữa chức năng Danh mục. đặt nó trong Thể loại của UIImage.

-(UIImage*)cropImage:(CGRect)rect{

    UIGraphicsBeginImageContextWithOptions(rect.size, false, [self scale]);
    [self drawAtPoint:CGPointMake(-rect.origin.x, -rect.origin.y)];
    UIImage* cropped_image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return cropped_image;
}

Tôi không hài lòng với các giải pháp khác vì chúng rút ra nhiều lần (sử dụng nhiều năng lượng hơn mức cần thiết) hoặc có vấn đề với định hướng. Đây là những gì tôi đã sử dụng cho một hình vuông được cắt theo tỷ lệ từ hình ảnh UIImage *.

CGFloat minimumSide = fminf(image.size.width, image.size.height);
CGFloat finalSquareSize = 600.;

//create new drawing context for right size
CGRect rect = CGRectMake(0, 0, finalSquareSize, finalSquareSize);
CGFloat scalingRatio = 640.0/minimumSide;
UIGraphicsBeginImageContext(rect.size);

//draw
[image drawInRect:CGRectMake((minimumSide - photo.size.width)*scalingRatio/2., (minimumSide - photo.size.height)*scalingRatio/2., photo.size.width*scalingRatio, photo.size.height*scalingRatio)];

UIImage *croppedImage = UIGraphicsGetImageFromCurrentImageContext();

UIGraphicsEndImageContext();

Tôi sử dụng phương pháp dưới đây.

  -(UIImage *)getNeedImageFrom:(UIImage*)image cropRect:(CGRect)rect
  {
    CGSize cropSize = rect.size;
    CGFloat widthScale =  
    image.size.width/self.imageViewOriginal.bounds.size.width;
    CGFloat heightScale = 
    image.size.height/self.imageViewOriginal.bounds.size.height;
    cropSize = CGSizeMake(rect.size.width*widthScale,  
    rect.size.height*heightScale);
    CGPoint  pointCrop = CGPointMake(rect.origin.x*widthScale, 
    rect.origin.y*heightScale);
    rect = CGRectMake(pointCrop.x, pointCrop.y, cropSize.width, 
    cropSize.height);
    CGImageRef subImage = CGImageCreateWithImageInRect(image.CGImage, rect);
    UIImage *croppedImage = [UIImage imageWithCGImage:subImage];
    CGImageRelease(subImage);
    return croppedImage;

}

Hãy xem https://github.com/vvbogdan/BVCropPhoto

- (UIImage *) croppingImage {
    CGFloat scale = self.sourceImage.size. Thong / self.scrollView.contentSize. Thong;

    UIImage * FinalImage = nil;
    CGRect targetFrame = CGRectMake ((self.scrollView.contentInset.left + self.scrollView.content Offerset.x) * scale,
            (self.scrollView.contentInset.top + self.scrollView.content Offerset.y) * scale,
            thang đo self.cropSize. thong *,
            thang đo self.cropSize.height *);

    CGImageRef bối cảnhImage = CGImageCreateWithImageInRect ([[self imageWithRotation: self.sourceImage] CGImage], targetFrame);

    if (bối cảnh! = NULL) {
        FinalImage = [UIImage imageWithCGImage: bối cảnh
                                         tỷ lệ: self.sourceImage.scale
                                   định hướng: UIImageOrientationUp];

        CGImageRelease (bối cảnh);
    }

    trả lại hình ảnh cuối cùng;
}


- (UIImage *) imageWithRotation: (UIImage *) image {


    if (image.imageOrientation == UIImageOrientationUp) trả lại hình ảnh;
    Biến đổi CGAffineTransform = CGAffineTransformIdentity;

    chuyển đổi (image.imageOrientation) {
        trường hợp UIImageOrientationDown:
        trường hợp UIImageOrientationDownMirrored:
            biến đổi = CGAffineTransformTranslate (biến đổi, image.size. thong, image.size.height);
            biến đổi = CGAffineTransformRotate (biến đổi, M_PI);
            phá vỡ;

        trường hợp UIImageOrientationLeft:
        trường hợp UIImageOrientationLeftMirrored:
            biến đổi = CGAffineTransformTranslate (biến đổi, image.size. thong, 0);
            biến đổi = CGAffineTransformRotate (biến đổi, M_PI_2);
            phá vỡ;

        trường hợp UIImageOrientationRight:
        trường hợp UIImageOrientationRightMirrored:
            biến đổi = CGAffineTransformTransTable (biến đổi, 0, image.size.height);
            biến đổi = CGAffineTransformRotate (biến đổi, -M_PI_2);
            phá vỡ;
        trường hợp UIImageOrientationUp:
        trường hợp UIImageOrientationUpMirrored:
            phá vỡ;
    }

    chuyển đổi (image.imageOrientation) {
        trường hợp UIImageOrientationUpMirrored:
        trường hợp UIImageOrientationDownMirrored:
            biến đổi = CGAffineTransformTranslate (biến đổi, image.size. thong, 0);
            biến đổi = CGAffineTransformScale (biến đổi, -1, 1);
            phá vỡ;

        trường hợp UIImageOrientationLeftMirrored:
        trường hợp UIImageOrientationRightMirrored:
            biến đổi = CGAffineTransformTransTable (biến đổi, image.size.height, 0);
            biến đổi = CGAffineTransformScale (biến đổi, -1, 1);
            phá vỡ;
        trường hợp UIImageOrientationUp:
        trường hợp UIImageOrientationDown:
        trường hợp UIImageOrientationLeft:
        trường hợp UIImageOrientationRight:
            phá vỡ;
    }

    // Bây giờ chúng ta vẽ CGImage cơ bản vào một bối cảnh mới, áp dụng biến đổi
    // đã tính ở trên.
    CGContextRef ctx = CGBitmapContextCreate (NULL, image.size. Thong, image.size.height,
            CGImageGetBitsPerComponent (image.CGImage), 0,
            CGImageGetColorSpace (image.CGImage),
            CGImageGetBitmapInfo (image.CGImage));
    CGContextConcatCTM (ctx, biến đổi);
    chuyển đổi (image.imageOrientation) {
        trường hợp UIImageOrientationLeft:
        trường hợp UIImageOrientationLeftMirrored:
        trường hợp UIImageOrientationRight:
        trường hợp UIImageOrientationRightMirrored:
            // Ơ ...
            CGContextDrawImage (ctx, CGRectMake (0, 0, image.size.height, image.size. Thong), image.CGImage);
            phá vỡ;

        mặc định:
            CGContextDrawImage (ctx, CGRectMake (0, 0, image.size. Thong, image.size.height), image.CGImage);
            phá vỡ;
    }

    // Và bây giờ chúng ta chỉ cần tạo một UIImage mới từ bối cảnh vẽ
    CGImageRef cgimg = CGBitmapContextCreateImage (ctx);
    UIImage * img = [hình ảnh UIImageWithCGImage: cgimg];
    CGContextRelease (ctx);
    CGImageRelease (cgimg);
    trả lại img;

}