이미지 크기를 조정하는 코드가있어 이미지 중심의 스케일 된 덩어리를 얻을 수 있습니다.이 이미지를 사용하여 이미지 UIImage의 작은 사각형 이미지 를 가져와 사진 앱. (a를 사용 UIImageView하고 자르기 모드를 조정하여 동일한 결과를 얻을 수는 있지만 이러한 이미지는 때때로에 표시됩니다 UIWebViews).

이 코드에서 충돌이 발생하기 시작했으며 약간 혼란 스러웠습니다. 나는 두 가지 다른 이론을 가지고 있으며 어느 쪽이 기초인지 궁금합니다.

이론 1) 대상 크기의 오프 스크린 이미지 컨텍스트를 그려 자르기를 수행합니다. 이미지의 중앙 부분을 원하기 때문에 CGRect인수를 drawInRect이미지 컨텍스트의 경계보다 큰 것으로 전달했습니다 . 나는 이것이 코셔 (Kosher)라고 기대했지만 대신 만져서는 안되는 다른 메모리를 가져 오려고합니까?

이론 2) 나는이 모든 것을 백그라운드 스레드에서하고 있습니다. 기본 스레드로 제한된 UIKit 부분이 있다는 것을 알고 있습니다. 오프 스크린보기로 그리는 것이 이것들 중 하나가 아니라고 가정 / 기대하고있었습니다. 내가 잘못?

(오, 방법이 그리워요 NSImage's drawInRect:fromRect:operation:fraction:.)

2014-05-28 업데이트 : iOS 3 정도가 새로운 것이었을 때 이것을 썼습니다. 지금까지 더 좋은 방법이있을 것이라고 확신합니다. 많은 사람들이 언급했듯이이 방법은 회전을 고려하지 않습니다. 이 질문에 대한 답변을 모든 사람에게 도움이되도록 추가 답변을 읽고 주위에 반한 사랑을 전하십시오.

원래 답변 :

다른 곳에서 같은 질문에 대한 답변을 복사 / 붙여 넣을 것입니다.

이 작업을 수행하는 간단한 클래스 메서드는 없지만 원하는 결과를 얻는 데 사용할 수있는 함수가 있습니다 CGImageCreateWithImageInRect(CGImageRef, CGRect).

다음은이를 사용하는 간단한 예입니다.

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

동일한 크기와 방향을 유지하면서 망막 이미지를 자르려면 UIImage 범주 (iOS 4.0 이상)에서 다음 방법을 사용하십시오.

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

UIImage 카테고리를 만들어 필요한 곳에서 사용할 수 있습니다. HitScans 응답 및 주석을 기반으로합니다.

@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

이 방법으로 사용할 수 있습니다 :

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

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

UIImage *croppedImage = [imageToCrop crop:cropRect];

스위프트 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

이 브리지 기능의 도움으로 CGRectMake-> CGRect( 이 답변 에 대한 답변은으로 답변 @rob mayoff) :

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

사용법은 다음과 같습니다.

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

산출:

다음은 imageOrientation 속성을 따르는 UIImage 자르기 구현입니다. 모든 오리엔테이션을 철저히 테스트했습니다.

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

헤딩 :이 모든 답변은 백업 CGImage이미지 객체를 가정 합니다.

image.CGImage이 경우, nil을 반환 할 수 있습니다 UIImagea로 백업됩니다 CIImage당신은을 사용하여 이미지를 만든 경우 경우가 것이다, CIFilter.

이 경우 새 컨텍스트에서 이미지를 그리고 해당 이미지를 반환해야합니다 ( slow ).

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

여기의 답변 중 어느 것도 모든 스케일 및 회전 문제를 100 % 올바르게 처리하지 못합니다. iOS7 / 8에서 지금까지 말한 모든 것을 종합 한 것입니다. 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;
}

awolf나를 위해 일한의 답변 스위프트 버전 :

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

내가 본 대부분의 응답은 (x, y)에 대한 위치 (0, 0) 만 처리합니다. 좋습니다. 한 가지 경우이지만 자르기 작업을 중앙에 배치하고 싶습니다. 알아내는 데 시간이 걸렸던 것은 WTF 의견 다음 줄입니다.

세로 방향으로 캡처 한 이미지를 예로 들어 보겠습니다.

1. 원래 이미지 높이가 너비보다 높습니다 (우, 지금까지 놀랍지 않습니다!)
2. CGImageCreateWithImageInRect 메소드가 자신의 세계에서 상상하는 이미지는 실제로 세로가 아니라 풍경입니다 (이것은 imageWithCGImage 생성자에서 orientation 인수를 사용하지 않으면 180 회전으로 표시됩니다).
3. 이미지가 오른쪽 상단 인 (0, 0) 위치 인 풍경이라고 상상해보십시오.

이해가 되길 바랍니다! 그렇지 않으면 다른 값을 시도하여 cropRect에 적합한 x, y, 너비 및 높이를 선택할 때 논리가 반전된다는 것을 알 수 있습니다.

swift3

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

스위프트 확장

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

정밀도, 픽셀 스케일링 측면 에서 Swift 에서 UIImage 자르기를위한 최상의 솔루션 :

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
}

이 함수를 호출하는 데 사용되는 지침 :

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

참고 : Objective-C로 작성된 초기 소스 코드 영감은 "Cocoanetics"블로그에서 찾을 수 있습니다.

아래 코드 스 니펫이 도움이 될 수 있습니다.

import UIKit

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

조금 이상하게 보이지만 훌륭하게 작동하며 이미지 방향을 고려합니다.

var image:UIImage = ...

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

스위프트 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;
}

iOS9.2SDK에서는 아래 방법을 사용하여 UIView에서 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;
}

Swift 2.0 업데이트 ( CIImage호환성)

Maxim의 답변에서 확장 되지만 이미지가 CIImage기반 인 경우에도 작동합니다 .

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

Noodles 답변을 기반으로 업데이트 된 Swift 3 버전이 있습니다.

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
}

@Arne의 답변을 따르십시오. 카테고리 기능으로 고정했습니다. 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;
}

다른 솔루션에 몇 시간이 걸리거나 (필요한 것보다 더 많은 전력을 사용함) 방향에 문제가 있기 때문에 다른 솔루션에 만족하지 못했습니다. 다음은 UIImage * 이미지에서 크기 조정 된 사각형 croppedImage에 사용한 것입니다.

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

아래 방법을 사용합니다.

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

}

https://github.com/vvbogdan/BVCropPhoto를 보십시오

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

    UIImage * finalImage = nil;
    CGRect targetFrame = CGRectMake ((self.scrollView.contentInset.left + self.scrollView.contentOffset.x) * 스케일,
            (self.scrollView.contentInset.top + self.scrollView.contentOffset.y) * 스케일,
            self.cropSize.width * 스케일,
            self.cropSize.height * 스케일);

    CGImageRef contextImage = CGImageCreateWithImageInRect ([[self imageWithRotation : self.sourceImage] CGImage], targetFrame);

    if (contextImage! = NULL) {
        finalImage = [UIImage imageWithCGImage : contextImage
                                         scale : self.sourceImage.scale
                                   orientation : UIImageOrientationUp];

        CGImageRelease (contextImage);
    }

    finalImage를 반환;
}


-(UIImage *) imageWithRotation : (UIImage *) 이미지 {


    if (image.imageOrientation == UIImageOrientationUp) 이미지를 반환합니다;
    CGAffineTransform 변환 = CGAffineTransformIdentity;

    스위치 (image.imageOrientation) {
        case UIImageOrientationDown :
        case UIImageOrientationDownMirrored :
            변환 = CGAffineTransformTranslate (변환, 이미지 크기, 너비, 이미지 크기);
            변환 = CGAffineTransformRotate (변환, M_PI);
            단절;

        case UIImageOrientationLeft :
        case UIImageOrientationLeftMirrored :
            변환 = CGAffineTransformTranslate (변환, image.size.width, 0);
            변환 = CGAffineTransformRotate (변환, M_PI_2);
            단절;

        case UIImageOrientationRight :
        case UIImageOrientationRightMirrored :
            변환 = CGAffineTransformTranslate (변환, 0, image.size.height);
            변환 = CGAffineTransformRotate (변환, -M_PI_2);
            단절;
        case UIImageOrientationUp :
        case UIImageOrientationUp 미러 :
            단절;
    }

    스위치 (image.imageOrientation) {
        case UIImageOrientationUp 미러 :
        case UIImageOrientationDownMirrored :
            변환 = CGAffineTransformTranslate (변환, image.size.width, 0);
            변환 = CGAffineTransformScale (변환, -1, 1);
            단절;

        case UIImageOrientationLeftMirrored :
        case UIImageOrientationRightMirrored :
            변환 = CGAffineTransformTranslate (변환, 이미지 크기. 높이, 0);
            변환 = CGAffineTransformScale (변환, -1, 1);
            단절;
        case UIImageOrientationUp :
        case UIImageOrientationDown :
        case UIImageOrientationLeft :
        case UIImageOrientationRight :
            단절;
    }

    // 이제 기본 CGImage를 새로운 컨텍스트에 그리면서 변형을 적용합니다.
    // 위에서 계산했습니다.
    CGContextRef ctx = CGBitmapContextCreate (NULL, image.size.width, image.size.height,
            CGImageGetBitsPerComponent (image.CGImage), 0,
            CGImageGetColorSpace (image.CGImage),
            CGImageGetBitmapInfo (image.CGImage));
    CGContextConcatCTM (ctx, 변환);
    스위치 (image.imageOrientation) {
        case UIImageOrientationLeft :
        case UIImageOrientationLeftMirrored :
        case UIImageOrientationRight :
        case UIImageOrientationRightMirrored :
            // Grr ...
            CGContextDrawImage (ctx, CGRectMake (0, 0, image.size.height, image.size.width), image.CGImage);
            단절;

        기본:
            CGContextDrawImage (ctx, CGRectMake (0, 0, image.size.width, image.size.height), image.CGImage);
            단절;
    }

    // 이제 드로잉 컨텍스트에서 새 UIImage를 만듭니다.
    CGImageRef cgimg = CGBitmapContextCreateImage (ctx);
    UIImage * img = [UIImage imageWithCGImage : cgimg];
    CGContextRelease (ctx);
    CGImageRelease (cgimg);
    img를 반환;

}