iOS-UIImageView-UIImage 이미지 방향 처리 방법

80

UIImageView이미지 방향을 처리 하도록 설정할 수 있습니까? RIGHTUIImageView 방향으로 이미지를 설정하면 (카메라 롤의 사진) 이미지가 오른쪽으로 회전하지만 촬영 된대로 올바른 방향으로 표시하고 싶습니다.

이미지 데이터를 회전 할 수 있다는 것을 알고 있지만 더 우아하게 할 수 있습니까?

ios  uiimageview  uiimage  orientation 
— 마틴 필치
소스

답변:

142

내가 이해한다면 UIImage의 방향을 무시하고 싶습니까? 그렇다면 다음과 같이 할 수 있습니다.

UIImage *originalImage = [... whatever ...];

UIImage *imageToDisplay =
     [UIImage imageWithCGImage:[originalImage CGImage]
              scale:[originalImage scale]
              orientation: UIImageOrientationUp];

따라서 원본과 동일한 픽셀 데이터 (CGImage 속성을 통해 참조 됨)로 새 UIImage를 생성하지만 데이터를 회전하지 않는 방향을 지정하고 있습니다.

— 나사 돌리개
소스
4
그런데 실제로 이미지 데이터를 어떻게 회전시킬 수 있습니까?
— 왕 리앙
7
나는 당신 CGContext이 CGBitmapContextCreate(또는 UIGraphicsBeginImageContext속기) 로 적절한 크기 를 만들고, CGContextRotateCTM회전을 설정하는 데 사용 drawInRect:하고, UIImage또는 CGContextDrawImage이미지의 CGImage속성과 함께 사용 UIGraphicsGetImageFromCurrentImageContext하고, 다음 중 하나를 사용하여 컨텍스트를 이미지로 변환 할 것이라고 UIGraphicsEndImageContext생각합니다. UIKit을 사용하여 컨텍스트를 만들거나 CGBitmapContextCreateImageCore Graphics를 고수하는 경우. UIKit은 스레드로부터 안전하지 않지만 코드는 더 깔끔 할 것입니다.
— Tommy
ImageView에 이미지를 넣을 때이 작업을 수행 할 수 없습니다. 미러링 된 방향으로 이미지를 생성하더라도 원래 방향으로 이미지를 표시합니다. [UIImage imageWithCGImage : image.CGImage scale : image .scale 동향 : UIImageOrientationUpMirrored는] ... 영업 이익은 이미지 뷰를 사용하는 방법에 대한 질문 그러나 나는 이미지 뷰에서 작업이 솔루션 ... 얻을 수 없습니다
— 에단 G
1
그러나 HEIC가 아닌 PNG에서 작동합니다.
— DawnSong
50

이 답변 에서 an0이 제안한 것처럼 수동으로 변환 및 크기 조정을 완전히 피할 수 있습니다 .

- (UIImage *)normalizedImage {
    if (self.imageOrientation == UIImageOrientationUp) return self; 

    UIGraphicsBeginImageContextWithOptions(self.size, NO, self.scale);
    [self drawInRect:(CGRect){0, 0, self.size}];
    UIImage *normalizedImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return normalizedImage;
}

UIImage 메서드 size 및 drawInRect에 대한 설명서에는 방향을 고려 한다고 명시되어 있습니다.

— 사용자 2067021
소스
1
이것은 생명의 은인입니다.
— Quark
이거 어디에 붙여야하나요?
— Frostmourne 2011
25

나는에 코드를 변환 여기 아노미의 대답 에 (suvish valsan 이상-붙여 복사) 스위프트 :

func fixOrientation() -> UIImage {
    if self.imageOrientation == UIImageOrientation.Up {
        return self
    }

    var transform = CGAffineTransformIdentity

    switch self.imageOrientation {
    case .Down, .DownMirrored:
        transform = CGAffineTransformTranslate(transform, self.size.width, self.size.height)
        transform = CGAffineTransformRotate(transform, CGFloat(M_PI));

    case .Left, .LeftMirrored:
        transform = CGAffineTransformTranslate(transform, self.size.width, 0);
        transform = CGAffineTransformRotate(transform, CGFloat(M_PI_2));

    case .Right, .RightMirrored:
        transform = CGAffineTransformTranslate(transform, 0, self.size.height);
        transform = CGAffineTransformRotate(transform, CGFloat(-M_PI_2));

    case .Up, .UpMirrored:
        break
    }

    switch self.imageOrientation {

    case .UpMirrored, .DownMirrored:
        transform = CGAffineTransformTranslate(transform, self.size.width, 0)
        transform = CGAffineTransformScale(transform, -1, 1)

    case .LeftMirrored, .RightMirrored:
        transform = CGAffineTransformTranslate(transform, self.size.height, 0)
        transform = CGAffineTransformScale(transform, -1, 1);

    default:
        break;
    }

    // Now we draw the underlying CGImage into a new context, applying the transform
    // calculated above.
    let ctx = CGBitmapContextCreate(
        nil,
        Int(self.size.width),
        Int(self.size.height),
        CGImageGetBitsPerComponent(self.CGImage),
        0,
        CGImageGetColorSpace(self.CGImage),
        UInt32(CGImageGetBitmapInfo(self.CGImage).rawValue)
    )

    CGContextConcatCTM(ctx, transform);

    switch self.imageOrientation {
    case .Left, .LeftMirrored, .Right, .RightMirrored:
        // Grr...
        CGContextDrawImage(ctx, CGRectMake(0, 0, self.size.height,self.size.width), self.CGImage);

    default:
        CGContextDrawImage(ctx, CGRectMake(0, 0, self.size.width,self.size.height), self.CGImage);
        break;
    }

    // And now we just create a new UIImage from the drawing context
    let cgimg = CGBitmapContextCreateImage(ctx)

    let img = UIImage(CGImage: cgimg!)

    return img;
}

(I 매개 변수의 모든 occurencies 교체 image로를 self내 코드가 확장이기 때문에 UIImage).

편집 : Swift 3 버전.

많은 중간 호출이 실패 할 수 있고을 사용하고 싶지 않기 때문에이 메서드는 선택 사항을 반환합니다 !.

func fixOrientation() -> UIImage? {

    guard let cgImage = self.cgImage else {
        return nil
    }

    if self.imageOrientation == UIImageOrientation.up {
        return self
    }

    let width  = self.size.width
    let height = self.size.height

    var transform = CGAffineTransform.identity

    switch self.imageOrientation {
    case .down, .downMirrored:
        transform = transform.translatedBy(x: width, y: height)
        transform = transform.rotated(by: CGFloat.pi)

    case .left, .leftMirrored:
        transform = transform.translatedBy(x: width, y: 0)
        transform = transform.rotated(by: 0.5*CGFloat.pi)

    case .right, .rightMirrored:
        transform = transform.translatedBy(x: 0, y: height)
        transform = transform.rotated(by: -0.5*CGFloat.pi)

    case .up, .upMirrored:
        break
    }

    switch self.imageOrientation {
    case .upMirrored, .downMirrored:
        transform = transform.translatedBy(x: width, y: 0)
        transform = transform.scaledBy(x: -1, y: 1)

    case .leftMirrored, .rightMirrored:
        transform = transform.translatedBy(x: height, y: 0)
        transform = transform.scaledBy(x: -1, y: 1)

    default:
        break;
    }

    // Now we draw the underlying CGImage into a new context, applying the transform
    // calculated above.
    guard let colorSpace = cgImage.colorSpace else {
        return nil
    }

    guard let context = CGContext(
        data: nil,
        width: Int(width),
        height: Int(height),
        bitsPerComponent: cgImage.bitsPerComponent,
        bytesPerRow: 0,
        space: colorSpace,
        bitmapInfo: UInt32(cgImage.bitmapInfo.rawValue)
        ) else {
            return nil
    }

    context.concatenate(transform);

    switch self.imageOrientation {

    case .left, .leftMirrored, .right, .rightMirrored:
        // Grr...
        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: height, height: width))

    default:
        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
    }

    // And now we just create a new UIImage from the drawing context
    guard let newCGImg = context.makeImage() else {
        return nil
    }

    let img = UIImage(cgImage: newCGImg)

    return img;
}

(참고 : Swift 3 버전 ode는 Xcode 8.1에서 컴파일되지만 실제로 작동하는지 테스트하지는 않았습니다. 어딘가에 오타가있을 수 있으며, 너비 / 높이 등이 섞여있을 수 있습니다. 오류를 가리 키거나 수정하십시오).

— 니콜라스 미아리
소스
위의 코드를 swift로 변환 한 후 사용했습니다. 3. 누구든지 신속한 3 버전이 필요한 경우 아래 내 답변을 확인하세요
— Waseem05
이미지 방향은 전혀 변경되지 않았습니다. 죄송합니다. 저는 iOS 개발이 처음입니다. 내가 한 일은 UIImage 확장 기능을 사용한 다음 프로그래밍 방식으로 func viewDidLoad. 이 이미지는 samsung phone photos.google.com/share/… 에서 가져온 것이며 270 CW 방향 exif 데이터가 있습니다. 사용 방법let background: UIImage? = UIImage(named: "background_image")?.fixOrientation() backgroundImage.image = background
— HendraWD
이 @Nicolas를 사용하여 메모리 누수 문제가 발생하는 사람이 있습니까? CGImage가 할당 해제되지 않은 것 같습니다. 내 앱은 대량 사진 관리 앱이며 많은 사진을 다룹니다. 이 함수는 실행될 때마다 메모리가 누출되는 것으로 보입니다. 이에 대한 빠른 수정이 있습니까?
— 마이클 라일리
@MichaelReilly Hmm, havnen은 자세히 보지 않았지만 CoreGraphics 호출은 ARC와 신속하게 작동해야합니다.
— 니콜라스 미아리
: @MichaelReilly 내 관찰을 확증하는 것이 답변 발견 stackoverflow.com/a/25790214/433373
— 니콜라스 미아리을
24

이 메서드는 먼저 UIImage의 현재 방향을 확인한 다음 시계 방향으로 방향을 변경하고 UIImage를 반환합니다.

self.imageView.image = rotateImage (currentUIImage)

   func rotateImage(image:UIImage)->UIImage
    {
        var rotatedImage = UIImage();
        switch image.imageOrientation
        {
            case UIImageOrientation.Right:
            rotatedImage = UIImage(CGImage:image.CGImage!, scale: 1, orientation:UIImageOrientation.Down);

           case UIImageOrientation.Down:
            rotatedImage = UIImage(CGImage:image.CGImage!, scale: 1, orientation:UIImageOrientation.Left);

            case UIImageOrientation.Left:
            rotatedImage = UIImage(CGImage:image.CGImage!, scale: 1, orientation:UIImageOrientation.Up);

             default:
            rotatedImage = UIImage(CGImage:image.CGImage!, scale: 1, orientation:UIImageOrientation.Right);
        }
        return rotatedImage;
    }

Swift 4 버전

func rotateImage(image:UIImage) -> UIImage
    {
        var rotatedImage = UIImage()
        switch image.imageOrientation
        {
        case .right:
            rotatedImage = UIImage(cgImage: image.cgImage!, scale: 1.0, orientation: .down)

        case .down:
            rotatedImage = UIImage(cgImage: image.cgImage!, scale: 1.0, orientation: .left)

        case .left:
            rotatedImage = UIImage(cgImage: image.cgImage!, scale: 1.0, orientation: .up)

        default:
            rotatedImage = UIImage(cgImage: image.cgImage!, scale: 1.0, orientation: .right)
        }

        return rotatedImage
    }
— 바 렌더 싱
소스
안녕하세요 Varender, 도움을 주셔서 감사합니다. 이것이 Martin에게 도움이 될 것이라고 생각하는 것에 대해 조금 발전시킬 수 있습니까? 귀하의 솔루션은 데이터 회전보다 얼마나 우아한 가요?
— J. Chomel
1. UIImageView에서 현재 UIImage를 가져옵니다. 2.이 메서드 (rotateImage)를 호출하고이 현재 UIImage를 인수로 전달합니다. 3. 반환 된 값을 UIImageView.image에 저장합니다. / * 이미지보기 내에서 데이터를 회전합니다. ) :)
— varender singh
저에 따르면 전체 UIImageView를 회전하면 UIImageView X가 음수 값이되기 때문에 최선의 대답입니다. 하지만 데이터를 회전하면 UIImageView가 제자리에 있고 데이터 만 회전됩니다. 정사각형 UIImageView를 사용하면 CGAffineTransformMakeRotate를 사용하여 전체 UIImageView를 간단히 변환 할 수 있습니다.
— varender singh
이것은 받아 들여진 대답이어야합니다! : 마법처럼 일했다
— 엘리 Dantas
rotatedImage =있는 UIImage : 신속한 3 (의 CGImage : image.cgImage !, 규모 : 1 방향 : UIImageOrientation.right)
— Ansal 안토니
19

스위프트 3.1

func fixImageOrientation(_ image: UIImage)->UIImage {
    UIGraphicsBeginImageContext(image.size)
    image.draw(at: .zero)
    let newImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return newImage ?? image
}
— 아쿠아
소스
이것은 완벽한 솔루션입니다. :)
— miff
당신은 모든 비트 내 친구 자격
— 미첼 갠트
이보다 더 나은 것을 . 이것은 신속한 4에서 작동하지만 그렇지 않습니다.
— AechoLiu 2011
감사. 이것은 대부분의 다른 답변으로 표시 될뿐만 아니라 이미지를 서버에 업로드해야 할 때 작동합니다.
— 유목민 개발자
잘 작동합니다. 이미지를 가져 와서 .up 방향으로 저장합니다.
— zumzum
9

Swift의 UIImage 확장. 정말 모든 뒤집기를 할 필요가 없습니다. Objective-C 원본이 여기 에 있지만 원본 이미지의 알파를 존중하는 비트를 추가했습니다 (조박하지만 투명 이미지와 불투명 한 이미지를 구분하는 데 효과적입니다).

// from https://github.com/mbcharbonneau/UIImage-Categories/blob/master/UIImage%2BAlpha.m
// Returns true if the image has an alpha layer
    private func hasAlpha() -> Bool {
        guard let cg = self.cgImage else { return false }
        let alpha = cg.alphaInfo
        let retVal = (alpha == .first || alpha == .last || alpha == .premultipliedFirst || alpha == .premultipliedLast)
        return retVal
    }

    func normalizedImage() -> UIImage? {
        if self.imageOrientation == .up {
            return self
        }
        UIGraphicsBeginImageContextWithOptions(self.size, !self.hasAlpha(), self.scale)
        var rect = CGRect.zero
        rect.size = self.size
        self.draw(in: rect)
        let retVal = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return retVal
    }
— 댄 로젠 스타크
소스
8

다음은 이미지 방향을 고려하여 실행 가능한 샘플 코드입니다.

#define rad(angle) ((angle) / 180.0 * M_PI)
- (CGAffineTransform)orientationTransformedRectOfImage:(UIImage *)img
{
    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;
    };

    return CGAffineTransformScale(rectTransform, img.scale, img.scale);
}


- (UIImage *)croppedImage:(UIImage*)orignialImage InRect:(CGRect)visibleRect{
    //transform visible rect to image orientation
    CGAffineTransform rectTransform = [self orientationTransformedRectOfImage:orignialImage];
    visibleRect = CGRectApplyAffineTransform(visibleRect, rectTransform);

    //crop image
    CGImageRef imageRef = CGImageCreateWithImageInRect([orignialImage CGImage], visibleRect);
    UIImage *result = [UIImage imageWithCGImage:imageRef scale:orignialImage.scale orientation:orignialImage.imageOrientation];
    CGImageRelease(imageRef);
    return result;
}
— lbsweek
소스
8

누구나 필요할 경우를 대비하여 @Nicolas Miari 답변의 코드를 Swift 3로 변환했습니다.

func fixOrientation() -> UIImage
{

    if self.imageOrientation == UIImageOrientation.up {
        return self
    }

    var transform = CGAffineTransform.identity

    switch self.imageOrientation {
    case .down, .downMirrored:
        transform = transform.translatedBy(x: self.size.width, y: self.size.height)
        transform = transform.rotated(by: CGFloat(M_PI));

    case .left, .leftMirrored:
        transform = transform.translatedBy(x: self.size.width, y: 0);
        transform = transform.rotated(by: CGFloat(M_PI_2));

    case .right, .rightMirrored:
        transform = transform.translatedBy(x: 0, y: self.size.height);
        transform = transform.rotated(by: CGFloat(-M_PI_2));

    case .up, .upMirrored:
        break
    }


    switch self.imageOrientation {

    case .upMirrored, .downMirrored:
        transform = transform.translatedBy(x: self.size.width, y: 0)
        transform = transform.scaledBy(x: -1, y: 1)

    case .leftMirrored, .rightMirrored:
        transform = transform.translatedBy(x: self.size.height, y: 0)
        transform = transform.scaledBy(x: -1, y: 1);

    default:
        break;
    }

    // Now we draw the underlying CGImage into a new context, applying the transform
    // calculated above.
    let ctx = CGContext(
        data: nil,
        width: Int(self.size.width),
        height: Int(self.size.height),
        bitsPerComponent: self.cgImage!.bitsPerComponent,
        bytesPerRow: 0,
        space: self.cgImage!.colorSpace!,
        bitmapInfo: UInt32(self.cgImage!.bitmapInfo.rawValue)
    )



    ctx!.concatenate(transform);

    switch self.imageOrientation {

    case .left, .leftMirrored, .right, .rightMirrored:
        // Grr...
        ctx?.draw(self.cgImage!, in: CGRect(x:0 ,y: 0 ,width: self.size.height ,height:self.size.width))

    default:
        ctx?.draw(self.cgImage!, in: CGRect(x:0 ,y: 0 ,width: self.size.width ,height:self.size.height))
        break;
    }

    // And now we just create a new UIImage from the drawing context
    let cgimg = ctx!.makeImage()

    let img = UIImage(cgImage: cgimg!)

    return img;

}
— Waseem05
소스
캡처 한 후 위임 메소드에서 이미지 imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any] let imageCaptured:UIImage = info[UIImagePickerControllerOriginalImage] as! UIImage :( 이미지는 항상 rightOrientation이 방법은 다시 이미지를 반환
— Sumeet Mourya
예 이미지 방향은 항상 .right이지만 UIImageView에 올바르게 표시됩니다. Apple에는 여기에 올바르게 표시하는 데 사용되는 내부 데이터가 있습니다.
— Waseem05
4

그의 Swift 3 번역에 대한 Waseem05 덕분에 그의 방법은 UIImage에 대한 확장 안에 래핑하고 다음과 같이 부모 클래스 외부 / 아래에 배치했을 때만 저에게 효과적이었습니다.

extension UIImage {

        func fixOrientation() -> UIImage
        {

            if self.imageOrientation == UIImageOrientation.up {
            return self
        }

        var transform = CGAffineTransform.identity

        switch self.imageOrientation {
        case .down, .downMirrored:
            transform = transform.translatedBy(x: self.size.width, y: self.size.height)
            transform = transform.rotated(by: CGFloat(M_PI));

        case .left, .leftMirrored:
            transform = transform.translatedBy(x: self.size.width, y: 0);
            transform = transform.rotated(by: CGFloat(M_PI_2));

        case .right, .rightMirrored:
            transform = transform.translatedBy(x: 0, y: self.size.height);
            transform = transform.rotated(by: CGFloat(-M_PI_2));

        case .up, .upMirrored:
            break
        }


        switch self.imageOrientation {

        case .upMirrored, .downMirrored:
            transform = transform.translatedBy(x: self.size.width, y: 0)
            transform = transform.scaledBy(x: -1, y: 1)

        case .leftMirrored, .rightMirrored:
            transform = transform.translatedBy(x: self.size.height, y: 0)
            transform = transform.scaledBy(x: -1, y: 1);

        default:
            break;
        }

        // Now we draw the underlying CGImage into a new context, applying the transform
        // calculated above.
        let ctx = CGContext(
            data: nil,
            width: Int(self.size.width),
            height: Int(self.size.height),
            bitsPerComponent: self.cgImage!.bitsPerComponent,
            bytesPerRow: 0,
            space: self.cgImage!.colorSpace!,
            bitmapInfo: UInt32(self.cgImage!.bitmapInfo.rawValue)
        )



        ctx!.concatenate(transform);

        switch self.imageOrientation {

        case .left, .leftMirrored, .right, .rightMirrored:
            // Grr...
            ctx?.draw(self.cgImage!, in: CGRect(x:0 ,y: 0 ,width: self.size.height ,height:self.size.width))

        default:
            ctx?.draw(self.cgImage!, in: CGRect(x:0 ,y: 0 ,width: self.size.width ,height:self.size.height))
            break;
        }

        // And now we just create a new UIImage from the drawing context
        let cgimg = ctx!.makeImage()

        let img = UIImage(cgImage: cgimg!)

        return img;

    }
}

그런 다음 다음과 같이 호출했습니다.

let correctedImage:UIImage = wonkyImage.fixOrientation()

그리고 모든 것이 잘되었습니다! Apple은 전면 / 후면 카메라 및 위 / 아래 / 왼쪽 / 오른쪽 기기 방향 메타 데이터가 필요하지 않을 때 방향을 더 쉽게 폐기 할 수 있도록해야합니다.

— Hawtakshun
소스
4

회전하고 고정해야하는 경우 확장 아래 이미지 방향이 유용 할 것입니다.

extension UIImage {

    public func imageRotatedByDegrees(degrees: CGFloat) -> UIImage {
        //Calculate the size of the rotated view's containing box for our drawing space
        let rotatedViewBox: UIView = UIView(frame: CGRect(x: 0, y: 0, width: self.size.width, height: self.size.height))
        let t: CGAffineTransform = CGAffineTransform(rotationAngle: degrees * CGFloat.pi / 180)
        rotatedViewBox.transform = t
        let rotatedSize: CGSize = rotatedViewBox.frame.size
        //Create the bitmap context
        UIGraphicsBeginImageContext(rotatedSize)
        let bitmap: CGContext = UIGraphicsGetCurrentContext()!
        //Move the origin to the middle of the image so we will rotate and scale around the center.
        bitmap.translateBy(x: rotatedSize.width / 2, y: rotatedSize.height / 2)
        //Rotate the image context
        bitmap.rotate(by: (degrees * CGFloat.pi / 180))
        //Now, draw the rotated/scaled image into the context
        bitmap.scaleBy(x: 1.0, y: -1.0)
        bitmap.draw(self.cgImage!, in: CGRect(x: -self.size.width / 2, y: -self.size.height / 2, width: self.size.width, height: self.size.height))
        let newImage: UIImage = UIGraphicsGetImageFromCurrentImageContext()!
        UIGraphicsEndImageContext()
        return newImage
    }


    public func fixedOrientation() -> UIImage {
        if imageOrientation == UIImageOrientation.up {
            return self
        }

        var transform: CGAffineTransform = CGAffineTransform.identity

        switch imageOrientation {
        case UIImageOrientation.down, UIImageOrientation.downMirrored:
            transform = transform.translatedBy(x: size.width, y: size.height)
            transform = transform.rotated(by: CGFloat.pi)
            break
        case UIImageOrientation.left, UIImageOrientation.leftMirrored:
            transform = transform.translatedBy(x: size.width, y: 0)
            transform = transform.rotated(by: CGFloat.pi/2)
            break
        case UIImageOrientation.right, UIImageOrientation.rightMirrored:
            transform = transform.translatedBy(x: 0, y: size.height)
            transform = transform.rotated(by: -CGFloat.pi/2)
            break
        case UIImageOrientation.up, UIImageOrientation.upMirrored:
            break
        }

        switch imageOrientation {
        case UIImageOrientation.upMirrored, UIImageOrientation.downMirrored:
            transform.translatedBy(x: size.width, y: 0)
            transform.scaledBy(x: -1, y: 1)
            break
        case UIImageOrientation.leftMirrored, UIImageOrientation.rightMirrored:
            transform.translatedBy(x: size.height, y: 0)
            transform.scaledBy(x: -1, y: 1)
        case UIImageOrientation.up, UIImageOrientation.down, UIImageOrientation.left, UIImageOrientation.right:
            break
        }

        let ctx: CGContext = CGContext(data: nil,
                                       width: Int(size.width),
                                       height: Int(size.height),
                                       bitsPerComponent: self.cgImage!.bitsPerComponent,
                                       bytesPerRow: 0,
                                       space: self.cgImage!.colorSpace!,
                                       bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!

        ctx.concatenate(transform)

        switch imageOrientation {
        case UIImageOrientation.left, UIImageOrientation.leftMirrored, UIImageOrientation.right, UIImageOrientation.rightMirrored:
            ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: size.height, height: size.width))
        default:
            ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
            break
        }

        let cgImage: CGImage = ctx.makeImage()!

        return UIImage(cgImage: cgImage)
    }
}
— 다발 H. 네나
소스
2 
extension UIImage {
    func fixImageOrientation() -> UIImage {
        UIGraphicsBeginImageContext(self.size)
        self.draw(at: .zero)
        let newImage = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return newImage ?? self
    }
}
  1. 상단 예제와 같은 확장을 만듭니다.

  2. 전화 : imageView.image?.fixImageOrientation()또는UIImage(named: "someImage").fixImageOrientation()

  3. 모두 행운을 빕니다!

— 미하일 살라 리
소스
이것은 잘 작동합니다. 그러나 메모리는 어떤 식 으로든 쌓이고 루프에서 호출되면 앱이 충돌합니다.
— abhimuralidharan
@abhimuralidharan, 루프를 확인하지 않았지만 100 % 적용 할 수있는 방법이 있습니다.
— Mihail Salari
1

Tommy의 답변의 Swift 3.0 버전

let imageToDisplay = UIImage.init(cgImage: originalImage.cgImage!, scale: originalImage.scale, orientation: UIImageOrientation.up)
— 압 두라 만 무빈 알리
소스
0

@Aqua Answer .....에서 영감을 얻었습니다.

Objective C에서

- (UIImage *)fixImageOrientation:(UIImage *)img {

   UIGraphicsBeginImageContext(img.size);
   [img drawAtPoint:CGPointZero];

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

   if (newImg) {
       return newImg;
   }

   return img;
}
— 우마 칸타
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.