blocks|key|955089|text|我想出了一个更简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|955090|-+(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;
}|code-block|syntax|javascript|955091|顺便说一句：@+not的代码没有考虑到scale，所以对2x的图像不起作用。|offset|length|style|CODE|955092|entityMap^0|0|0|J|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I figured out a much simpler one:

<pre><code>- (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;
}
</code></pre>

BTW: @Anomie's code does not take <code>scale</code> into account, so will not work for 2x images.

blocks|key|739196|text|我在设计我的拍照应用程序时使用了这个页面，我发现以下方法将纠正方向，并比之前的答案使用更少的内存和处理器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739197|CGImageRef+cgRef+=+image.CGImage;
image+=+[[UIImage+alloc]+initWithCGImage:cgRef+scale:1.0+orientation:UIImageOrientationUp];|code-block|syntax|javascript|739198|这基本上只是用一个新的方向重新包装实际的图像数据。我使用的是@an0的代码，但它在内存中生成了一个新图像，这可能会对您可能从相机获得的3264x2448图像造成负担。|739199|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I used this page when designing my app that takes pictures and I found that the following method will correct the orientation and use less memory and processor than previous answers:

<pre><code>CGImageRef cgRef = image.CGImage;
image = [[UIImage alloc] initWithCGImage:cgRef scale:1.0 orientation:UIImageOrientationUp];
</code></pre>

This basically just rewraps the actual image data with a new orientation. I was using @an0's code but it makes a new image in memory which can be taxing on a 3264x2448 image that you might get from a camera.

blocks|key|739213|text|如果启用编辑，则编辑后的图像(与原始图像相反)将按预期方向显示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739214|UIImagePickerController+*imagePickerController+=+[[UIImagePickerController+alloc]+init];
imagePickerController.allowsEditing+=+YES;
//+set+delegate+and+present+controller

-+(void)imagePickerController:(UIImagePickerController+*)picker+didFinishPickingMediaWithInfo:(NSDictionary+*)info+{
++++UIImage+*photo+=+[info+valueForKey:UIImagePickerControllerEditedImage];
++++//+do+whatever
}|code-block|syntax|javascript|739215|启用编辑允许用户在点击“使用照片”之前调整图像大小和移动图像|739216|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you enable editing, then the edited image (as opposed to the original) will be oriented as expected:

<pre><code>UIImagePickerController *imagePickerController = [[UIImagePickerController alloc] init];
imagePickerController.allowsEditing = YES;
// set delegate and present controller

- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info {
 UIImage *photo = [info valueForKey:UIImagePickerControllerEditedImage];
 // do whatever
}
</code></pre>

Enabling editing allows the user to resize and move the image before tapping "Use Photo"

blocks|key|739256|text|在swift+;)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739257|更新SWIFT+3.0+:D|739258|func+sFunc_imageFixOrientation(img:UIImage)+->+UIImage+{


++++//+No-op+if+the+orientation+is+already+correct
++++if+(img.imageOrientation+==+UIImageOrientation.up)+{
++++++++return+img;
++++}
++++//+We+need+to+calculate+the+proper+transformation+to+make+the+image+upright.
++++//+We+do+it+in+2+steps:+Rotate+if+Left/Right/Down,+and+then+flip+if+Mirrored.
++++var+transform:CGAffineTransform+=+CGAffineTransform.identity

++++if+(img.imageOrientation+==+UIImageOrientation.down
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.downMirrored)+{

++++++++transform+=+transform.translatedBy(x:+img.size.width,+y:+img.size.height)
++++++++transform+=+transform.rotated(by:+CGFloat(M_PI))
++++}

++++if+(img.imageOrientation+==+UIImageOrientation.left
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.leftMirrored)+{

++++++++transform+=+transform.translatedBy(x:+img.size.width,+y:+0)
++++++++transform+=+transform.rotated(by:+CGFloat(M_PI_2))
++++}

++++if+(img.imageOrientation+==+UIImageOrientation.right
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.rightMirrored)+{

++++++++transform+=+transform.translatedBy(x:+0,+y:+img.size.height);
++++++++transform+=+transform.rotated(by:+CGFloat(-M_PI_2));
++++}

++++if+(img.imageOrientation+==+UIImageOrientation.upMirrored
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.downMirrored)+{

++++++++transform+=+transform.translatedBy(x:+img.size.width,+y:+0)
++++++++transform+=+transform.scaledBy(x:+-1,+y:+1)
++++}

++++if+(img.imageOrientation+==+UIImageOrientation.leftMirrored
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.rightMirrored)+{

++++++++transform+=+transform.translatedBy(x:+img.size.height,+y:+0);
++++++++transform+=+transform.scaledBy(x:+-1,+y:+1);
++++}


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

++++ctx.concatenate(transform)


++++if+(img.imageOrientation+==+UIImageOrientation.left
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.leftMirrored
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.right
++++++++%7C%7C+img.imageOrientation+==+UIImageOrientation.rightMirrored
++++++++)+{


++++++++ctx.draw(img.cgImage!,+in:+CGRect(x:0,y:0,width:img.size.height,height:img.size.width))

++++}+else+{
++++++++ctx.draw(img.cgImage!,+in:+CGRect(x:0,y:0,width:img.size.width,height:img.size.height))
++++}


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

++++return+imgEnd
}|code-block|syntax|javascript|739259|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

in swift ;)

UPDATE SWIFT 3.0 :D

<pre><code>func sFunc_imageFixOrientation(img:UIImage) -&gt; UIImage {


 // No-op if the orientation is already correct
 if (img.imageOrientation == UIImageOrientation.up) {
 return img;
 }
 // We need to calculate the proper transformation to make the image upright.
 // We do it in 2 steps: Rotate if Left/Right/Down, and then flip if Mirrored.
 var transform:CGAffineTransform = CGAffineTransform.identity

 if (img.imageOrientation == UIImageOrientation.down
 || img.imageOrientation == UIImageOrientation.downMirrored) {

 transform = transform.translatedBy(x: img.size.width, y: img.size.height)
 transform = transform.rotated(by: CGFloat(M_PI))
 }

 if (img.imageOrientation == UIImageOrientation.left
 || img.imageOrientation == UIImageOrientation.leftMirrored) {

 transform = transform.translatedBy(x: img.size.width, y: 0)
 transform = transform.rotated(by: CGFloat(M_PI_2))
 }

 if (img.imageOrientation == UIImageOrientation.right
 || img.imageOrientation == UIImageOrientation.rightMirrored) {

 transform = transform.translatedBy(x: 0, y: img.size.height);
 transform = transform.rotated(by: CGFloat(-M_PI_2));
 }

 if (img.imageOrientation == UIImageOrientation.upMirrored
 || img.imageOrientation == UIImageOrientation.downMirrored) {

 transform = transform.translatedBy(x: img.size.width, y: 0)
 transform = transform.scaledBy(x: -1, y: 1)
 }

 if (img.imageOrientation == UIImageOrientation.leftMirrored
 || img.imageOrientation == UIImageOrientation.rightMirrored) {

 transform = transform.translatedBy(x: img.size.height, y: 0);
 transform = transform.scaledBy(x: -1, y: 1);
 }


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

 ctx.concatenate(transform)


 if (img.imageOrientation == UIImageOrientation.left
 || img.imageOrientation == UIImageOrientation.leftMirrored
 || img.imageOrientation == UIImageOrientation.right
 || img.imageOrientation == UIImageOrientation.rightMirrored
 ) {


 ctx.draw(img.cgImage!, in: CGRect(x:0,y:0,width:img.size.height,height:img.size.width))

 } else {
 ctx.draw(img.cgImage!, in: CGRect(x:0,y:0,width:img.size.width,height:img.size.height))
 }


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

 return imgEnd
}
</code></pre>

blocks|key|955174|text|以下是@an0给出的答案的Swift版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|955175|func+normalizedImage()+->+UIImage+{

++if+(self.imageOrientation+==+UIImageOrientation.Up)+{+
++++++return+self;
++}

++UIGraphicsBeginImageContextWithOptions(self.size,+false,+self.scale);
++let+rect+=+CGRect(x:+0,+y:+0,+width:+self.size.width,+height:+self.size.height)
++self.drawInRect(rect)

++let+normalizedImage+:+UIImage+=+UIGraphicsGetImageFromCurrentImageContext()
++UIGraphicsEndImageContext();
++return+normalizedImage;
}|code-block|syntax|javascript|955176|另外，在更一般的函数中：|955177|func+fixOrientation(img:UIImage)+->+UIImage+{

++if+(img.imageOrientation+==+UIImageOrientation.Up)+{+
++++++return+img;
++}

++UIGraphicsBeginImageContextWithOptions(img.size,+false,+img.scale);
++let+rect+=+CGRect(x:+0,+y:+0,+width:+img.size.width,+height:+img.size.height)
++img.drawInRect(rect)

++let+normalizedImage+:+UIImage+=+UIGraphicsGetImageFromCurrentImageContext()
++UIGraphicsEndImageContext();
++return+normalizedImage;

}|955178|Swift+3版本：|955179|func+fixOrientation(img:+UIImage)+->+UIImage+{
++++if+(img.imageOrientation+==+.up)+{
++++++++return+img
++++}

++++UIGraphicsBeginImageContextWithOptions(img.size,+false,+img.scale)
++++let+rect+=+CGRect(x:+0,+y:+0,+width:+img.size.width,+height:+img.size.height)
++++img.draw(in:+rect)

++++let+normalizedImage+=+UIGraphicsGetImageFromCurrentImageContext()!
++++UIGraphicsEndImageContext()

++++return+normalizedImage
}|955180|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here is a Swift version of the answer by @an0:

<pre><code>func normalizedImage() -&gt; UIImage {

 if (self.imageOrientation == UIImageOrientation.Up) { 
 return self;
 }

 UIGraphicsBeginImageContextWithOptions(self.size, false, self.scale);
 let rect = CGRect(x: 0, y: 0, width: self.size.width, height: self.size.height)
 self.drawInRect(rect)

 let normalizedImage : UIImage = UIGraphicsGetImageFromCurrentImageContext()
 UIGraphicsEndImageContext();
 return normalizedImage;
}
</code></pre>

Also in a more general function:

<pre><code>func fixOrientation(img:UIImage) -&gt; UIImage {

 if (img.imageOrientation == UIImageOrientation.Up) { 
 return img;
 }

 UIGraphicsBeginImageContextWithOptions(img.size, false, img.scale);
 let rect = CGRect(x: 0, y: 0, width: img.size.width, height: img.size.height)
 img.drawInRect(rect)

 let normalizedImage : UIImage = UIGraphicsGetImageFromCurrentImageContext()
 UIGraphicsEndImageContext();
 return normalizedImage;

}
</code></pre>

Swift 3 version:

<pre><code>func fixOrientation(img: UIImage) -&gt; UIImage {
 if (img.imageOrientation == .up) {
 return img
 }

 UIGraphicsBeginImageContextWithOptions(img.size, false, img.scale)
 let rect = CGRect(x: 0, y: 0, width: img.size.width, height: img.size.height)
 img.draw(in: rect)

 let normalizedImage = UIGraphicsGetImageFromCurrentImageContext()!
 UIGraphicsEndImageContext()

 return normalizedImage
}
</code></pre>

blocks|key|739325|text|下面是swift的UIImage扩展：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739326|extension+UIImage+{

++++func+fixOrientation()+->+UIImage+{

++++++++//+No-op+if+the+orientation+is+already+correct
++++++++if+(+self.imageOrientation+==+UIImageOrientation.Up+)+{
++++++++++++return+self;
++++++++}

++++++++//+We+need+to+calculate+the+proper+transformation+to+make+the+image+upright.
++++++++//+We+do+it+in+2+steps:+Rotate+if+Left/Right/Down,+and+then+flip+if+Mirrored.
++++++++var+transform:+CGAffineTransform+=+CGAffineTransformIdentity

++++++++if+(+self.imageOrientation+==+UIImageOrientation.Down+%7C%7C+self.imageOrientation+==+UIImageOrientation.DownMirrored+)+{
++++++++++++transform+=+CGAffineTransformTranslate(transform,+self.size.width,+self.size.height)
++++++++++++transform+=+CGAffineTransformRotate(transform,+CGFloat(M_PI))
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.Left+%7C%7C+self.imageOrientation+==+UIImageOrientation.LeftMirrored+)+{
++++++++++++transform+=+CGAffineTransformTranslate(transform,+self.size.width,+0)
++++++++++++transform+=+CGAffineTransformRotate(transform,+CGFloat(M_PI_2))
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.Right+%7C%7C+self.imageOrientation+==+UIImageOrientation.RightMirrored+)+{
++++++++++++transform+=+CGAffineTransformTranslate(transform,+0,+self.size.height);
++++++++++++transform+=+CGAffineTransformRotate(transform,++CGFloat(-M_PI_2));
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.UpMirrored+%7C%7C+self.imageOrientation+==+UIImageOrientation.DownMirrored+)+{
++++++++++++transform+=+CGAffineTransformTranslate(transform,+self.size.width,+0)
++++++++++++transform+=+CGAffineTransformScale(transform,+-1,+1)
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.LeftMirrored+%7C%7C+self.imageOrientation+==+UIImageOrientation.RightMirrored+)+{
++++++++++++transform+=+CGAffineTransformTranslate(transform,+self.size.height,+0);
++++++++++++transform+=+CGAffineTransformScale(transform,+-1,+1);
++++++++}

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

++++++++CGContextConcatCTM(ctx,+transform)

++++++++if+(+self.imageOrientation+==+UIImageOrientation.Left+%7C%7C
++++++++++++self.imageOrientation+==+UIImageOrientation.LeftMirrored+%7C%7C
++++++++++++self.imageOrientation+==+UIImageOrientation.Right+%7C%7C
++++++++++++self.imageOrientation+==+UIImageOrientation.RightMirrored+)+{
++++++++++++++++CGContextDrawImage(ctx,+CGRectMake(0,0,self.size.height,self.size.width),+self.CGImage)
++++++++}+else+{
++++++++++++CGContextDrawImage(ctx,+CGRectMake(0,0,self.size.width,self.size.height),+self.CGImage)
++++++++}

++++++++//+And+now+we+just+create+a+new+UIImage+from+the+drawing+context+and+return+it
++++++++return+UIImage(CGImage:+CGBitmapContextCreateImage(ctx))!
++++}
}|code-block|syntax|javascript|739327|基于MetalHeart2003的早期工作..|739328|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's UIImage extension for swift:

<pre><code>extension UIImage {

 func fixOrientation() -&gt; UIImage {

 // No-op if the orientation is already correct
 if ( self.imageOrientation == UIImageOrientation.Up ) {
 return self;
 }

 // We need to calculate the proper transformation to make the image upright.
 // We do it in 2 steps: Rotate if Left/Right/Down, and then flip if Mirrored.
 var transform: CGAffineTransform = CGAffineTransformIdentity

 if ( self.imageOrientation == UIImageOrientation.Down || self.imageOrientation == UIImageOrientation.DownMirrored ) {
 transform = CGAffineTransformTranslate(transform, self.size.width, self.size.height)
 transform = CGAffineTransformRotate(transform, CGFloat(M_PI))
 }

 if ( self.imageOrientation == UIImageOrientation.Left || self.imageOrientation == UIImageOrientation.LeftMirrored ) {
 transform = CGAffineTransformTranslate(transform, self.size.width, 0)
 transform = CGAffineTransformRotate(transform, CGFloat(M_PI_2))
 }

 if ( self.imageOrientation == UIImageOrientation.Right || self.imageOrientation == UIImageOrientation.RightMirrored ) {
 transform = CGAffineTransformTranslate(transform, 0, self.size.height);
 transform = CGAffineTransformRotate(transform, CGFloat(-M_PI_2));
 }

 if ( self.imageOrientation == UIImageOrientation.UpMirrored || self.imageOrientation == UIImageOrientation.DownMirrored ) {
 transform = CGAffineTransformTranslate(transform, self.size.width, 0)
 transform = CGAffineTransformScale(transform, -1, 1)
 }

 if ( self.imageOrientation == UIImageOrientation.LeftMirrored || self.imageOrientation == UIImageOrientation.RightMirrored ) {
 transform = CGAffineTransformTranslate(transform, self.size.height, 0);
 transform = CGAffineTransformScale(transform, -1, 1);
 }

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

 CGContextConcatCTM(ctx, transform)

 if ( self.imageOrientation == UIImageOrientation.Left ||
 self.imageOrientation == UIImageOrientation.LeftMirrored ||
 self.imageOrientation == UIImageOrientation.Right ||
 self.imageOrientation == UIImageOrientation.RightMirrored ) {
 CGContextDrawImage(ctx, CGRectMake(0,0,self.size.height,self.size.width), self.CGImage)
 } else {
 CGContextDrawImage(ctx, CGRectMake(0,0,self.size.width,self.size.height), self.CGImage)
 }

 // And now we just create a new UIImage from the drawing context and return it
 return UIImage(CGImage: CGBitmapContextCreateImage(ctx))!
 }
}
</code></pre>

Based on MetalHeart2003's earlier work..

blocks|key|739374|text|这是Swift+2中的一个UIImage扩展，基于@UIImage的公认答案。它使用更清晰的开关盒。它还考虑了CGBitmapContextCreateImage()返回的可选值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|739375|extension+UIImage+{
++++func+rotateImageByOrientation()+->+UIImage+{
++++++++//+No-op+if+the+orientation+is+already+correct
++++++++guard+self.imageOrientation+!=+.Up+else+{
++++++++++++return+self
++++++++}

++++++++//+We+need+to+calculate+the+proper+transformation+to+make+the+image+upright.
++++++++//+We+do+it+in+2+steps:+Rotate+if+Left/Right/Down,+and+then+flip+if+Mirrored.
++++++++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))

++++++++default:
++++++++++++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),
++++++++++++CGImageGetBitmapInfo(self.CGImage).rawValue)
++++++++CGContextConcatCTM(ctx,+transform)
++++++++switch+(self.imageOrientation)+{
++++++++case+.Left,+.LeftMirrored,+.Right,+.RightMirrored:
++++++++++++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)
++++++++}

++++++++//+And+now+we+just+create+a+new+UIImage+from+the+drawing+context
++++++++if+let+cgImage+=+CGBitmapContextCreateImage(ctx)+{
++++++++++++return+UIImage(CGImage:+cgImage)
++++++++}+else+{
++++++++++++return+self
++++++++}
++++}
}|code-block|syntax|javascript|739376|entityMap^0|1J|S|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Here is an UIImage extension in Swift 2 based on the accepted answer by @Anomie. It uses a clearer switch case. It also takes the optional value returned by <code>CGBitmapContextCreateImage()</code> into consideration.

<pre><code>extension UIImage {
 func rotateImageByOrientation() -&gt; UIImage {
 // No-op if the orientation is already correct
 guard self.imageOrientation != .Up else {
 return self
 }

 // We need to calculate the proper transformation to make the image upright.
 // We do it in 2 steps: Rotate if Left/Right/Down, and then flip if Mirrored.
 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))

 default:
 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),
 CGImageGetBitmapInfo(self.CGImage).rawValue)
 CGContextConcatCTM(ctx, transform)
 switch (self.imageOrientation) {
 case .Left, .LeftMirrored, .Right, .RightMirrored:
 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)
 }

 // And now we just create a new UIImage from the drawing context
 if let cgImage = CGBitmapContextCreateImage(ctx) {
 return UIImage(CGImage: cgImage)
 } else {
 return self
 }
 }
}
</code></pre>

blocks|key|955326|text|如果我理解的话，你想做的是忽略UIImage的方向？如果是这样，那么您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|955327|//image+is+your+original+image
image+=+[UIImage+imageWithCGImage:[image+CGImage]
+++++++++++++++++++++++++++++scale:[image+scale]
+++++++++++++++++++++++orientation:+UIImageOrientationUp];|code-block|syntax|javascript|955328|或者在Swift中：|955329|image+=+UIImage(CGImage:+image.CGImage!,+scale:+image.scale,+orientation:.Up)|955330|它解决了我的裁剪问题..霍普，这就是你要找的..|955331|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If I understand, what you want to do is disregard the orientation of the UIImage? If so then you could do this:-

<pre><code>//image is your original image
image = [UIImage imageWithCGImage:[image CGImage]
 scale:[image scale]
 orientation: UIImageOrientationUp];
</code></pre>

or in Swift :-

<pre><code>image = UIImage(CGImage: image.CGImage!, scale: image.scale, orientation:.Up)
</code></pre>

It solved my cropping issue.. Hope, this is what you're looking for..

blocks|key|739498|text|基于@jake1981的Swift+3版本，该版本来自@MetalHeart2003|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739499|extension+UIImage+{

++++func+fixOrientation()+->+UIImage+{

++++++++//+No-op+if+the+orientation+is+already+correct
++++++++if+(+self.imageOrientation+==+UIImageOrientation.up+)+{
++++++++++++return+self;
++++++++}

++++++++//+We+need+to+calculate+the+proper+transformation+to+make+the+image+upright.
++++++++//+We+do+it+in+2+steps:+Rotate+if+Left/Right/Down,+and+then+flip+if+Mirrored.

++++++++var+transform:+CGAffineTransform+=+CGAffineTransform.identity

++++++++if+(+self.imageOrientation+==+UIImageOrientation.down+%7C%7C+self.imageOrientation+==+UIImageOrientation.downMirrored+)+{
++++++++++++transform+=+transform.translatedBy(x:+self.size.width,+y:+self.size.height)
++++++++++++transform+=+transform.rotated(by:+CGFloat(M_PI))
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.left+%7C%7C+self.imageOrientation+==+UIImageOrientation.leftMirrored+)+{
++++++++++++transform+=+transform.translatedBy(x:+self.size.width,+y:+0)
++++++++++++transform+=+transform.rotated(by:+CGFloat(M_PI_2))
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.right+%7C%7C+self.imageOrientation+==+UIImageOrientation.rightMirrored+)+{
++++++++++++transform+=+transform.translatedBy(x:+0,+y:+self.size.height);
++++++++++++transform+=+transform.rotated(by:+CGFloat(-M_PI_2));
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.upMirrored+%7C%7C+self.imageOrientation+==+UIImageOrientation.downMirrored+)+{
++++++++++++transform+=+transform.translatedBy(x:+self.size.width,+y:+0)
++++++++++++transform+=+transform.scaledBy(x:+-1,+y:+1)
++++++++}

++++++++if+(+self.imageOrientation+==+UIImageOrientation.leftMirrored+%7C%7C+self.imageOrientation+==+UIImageOrientation.rightMirrored+)+{
++++++++++++transform+=+transform.translatedBy(x:+self.size.height,+y:+0);
++++++++++++transform+=+transform.scaledBy(x:+-1,+y:+1);
++++++++}

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

++++++++if+(+self.imageOrientation+==+UIImageOrientation.left+%7C%7C
++++++++++++self.imageOrientation+==+UIImageOrientation.leftMirrored+%7C%7C
++++++++++++self.imageOrientation+==+UIImageOrientation.right+%7C%7C
++++++++++++self.imageOrientation+==+UIImageOrientation.rightMirrored+)+{

++++++++++++ctx.draw(self.cgImage!,+in:+CGRect(x:+0,+y:+0,+width:+self.size.height,+height:+self.size.width))
++++++++}+else+{
++++++++++++ctx.draw(self.cgImage!,+in:+CGRect(x:+0,+y:+0,+width:+self.size.width,+height:+self.size.height))
++++++++}

++++++++//+And+now+we+just+create+a+new+UIImage+from+the+drawing+context+and+return+it
++++++++return+UIImage(cgImage:+ctx.makeImage()!)

++++}
}|code-block|syntax|javascript|739500|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Swift 3 version based on @jake1981 who've taken it from @MetalHeart2003

<pre><code>extension UIImage {

 func fixOrientation() -&gt; UIImage {

 // No-op if the orientation is already correct
 if ( self.imageOrientation == UIImageOrientation.up ) {
 return self;
 }

 // We need to calculate the proper transformation to make the image upright.
 // We do it in 2 steps: Rotate if Left/Right/Down, and then flip if Mirrored.

 var transform: CGAffineTransform = CGAffineTransform.identity

 if ( self.imageOrientation == UIImageOrientation.down || self.imageOrientation == UIImageOrientation.downMirrored ) {
 transform = transform.translatedBy(x: self.size.width, y: self.size.height)
 transform = transform.rotated(by: CGFloat(M_PI))
 }

 if ( self.imageOrientation == UIImageOrientation.left || self.imageOrientation == UIImageOrientation.leftMirrored ) {
 transform = transform.translatedBy(x: self.size.width, y: 0)
 transform = transform.rotated(by: CGFloat(M_PI_2))
 }

 if ( self.imageOrientation == UIImageOrientation.right || self.imageOrientation == UIImageOrientation.rightMirrored ) {
 transform = transform.translatedBy(x: 0, y: self.size.height);
 transform = transform.rotated(by: CGFloat(-M_PI_2));
 }

 if ( self.imageOrientation == UIImageOrientation.upMirrored || self.imageOrientation == UIImageOrientation.downMirrored ) {
 transform = transform.translatedBy(x: self.size.width, y: 0)
 transform = transform.scaledBy(x: -1, y: 1)
 }

 if ( self.imageOrientation == UIImageOrientation.leftMirrored || self.imageOrientation == UIImageOrientation.rightMirrored ) {
 transform = transform.translatedBy(x: self.size.height, y: 0);
 transform = transform.scaledBy(x: -1, y: 1);
 }

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

 if ( self.imageOrientation == UIImageOrientation.left ||
 self.imageOrientation == UIImageOrientation.leftMirrored ||
 self.imageOrientation == UIImageOrientation.right ||
 self.imageOrientation == UIImageOrientation.rightMirrored ) {

 ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: self.size.height, height: self.size.width))
 } else {
 ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: self.size.width, height: self.size.height))
 }

 // And now we just create a new UIImage from the drawing context and return it
 return UIImage(cgImage: ctx.makeImage()!)

 }
}
</code></pre>

blocks|key|955440|text|基于Sourabh+Sharma的答案对Swift+3.1进行了更新，并清理了代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|955441|extension+UIImage+{
++++func+fixedOrientation()+->+UIImage+{
++++++++if+imageOrientation+==+.up+{+return+self+}

++++++++var+transform:CGAffineTransform+=+.identity
++++++++switch+imageOrientation+{
++++++++case+.down,+.downMirrored:
++++++++++++transform+=+transform.translatedBy(x:+size.width,+y:+size.height).rotated(by:+.pi)
++++++++case+.left,+.leftMirrored:
++++++++++++transform+=+transform.translatedBy(x:+size.width,+y:+0).rotated(by:+.pi/2)
++++++++case+.right,+.rightMirrored:
++++++++++++transform+=+transform.translatedBy(x:+0,+y:+size.height).rotated(by:+-.pi/2)
++++++++default:+break
++++++++}

++++++++switch+imageOrientation+{
++++++++case+.upMirrored,+.downMirrored:
++++++++++++transform+=+transform.translatedBy(x:+size.width,+y:+0).scaledBy(x:+-1,+y:+1)
++++++++case+.leftMirrored,+.rightMirrored:
++++++++++++transform+=+transform.translatedBy(x:+size.height,+y:+0).scaledBy(x:+-1,+y:+1)
++++++++default:+break
++++++++}

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

++++++++switch+imageOrientation+{
++++++++case+.left,+.leftMirrored,+.right,+.rightMirrored:
++++++++++++ctx.draw(cgImage!,+in:+CGRect(x:+0,+y:+0,+width:+size.height,height:+size.width))
++++++++default:
++++++++++++ctx.draw(cgImage!,+in:+CGRect(x:+0,+y:+0,+width:+size.width,height:+size.height))
++++++++}
++++++++return+UIImage(cgImage:+ctx.makeImage()!)
++++}
}|code-block|syntax|javascript|955442|Picker委托方法示例：|955443|func+imagePickerController(_+picker:+UIImagePickerController,+didFinishPickingMediaWithInfo+info:+[String+:+Any])+{
++++guard+let+originalImage+=+info[UIImagePickerControllerOriginalImage]+as?+UIImage+else+{+return+}
++++let+fixedImage+=+originalImage.fixedOrientation()
++++//+do+your+work
}|955444|entityMap^0|2|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Update for Swift 3.1 based on <code>Sourabh Sharma</code>'s answer, with code clean up.

<pre><code>extension UIImage {
 func fixedOrientation() -&gt; UIImage {
 if imageOrientation == .up { return self }

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

 switch imageOrientation {
 case .upMirrored, .downMirrored:
 transform = transform.translatedBy(x: size.width, y: 0).scaledBy(x: -1, y: 1)
 case .leftMirrored, .rightMirrored:
 transform = transform.translatedBy(x: size.height, y: 0).scaledBy(x: -1, y: 1)
 default: break
 }

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

 switch imageOrientation {
 case .left, .leftMirrored, .right, .rightMirrored:
 ctx.draw(cgImage!, in: CGRect(x: 0, y: 0, width: size.height,height: size.width))
 default:
 ctx.draw(cgImage!, in: CGRect(x: 0, y: 0, width: size.width,height: size.height))
 }
 return UIImage(cgImage: ctx.makeImage()!)
 }
}
</code></pre>

Picker delegate method example:

<pre><code>func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any]) {
 guard let originalImage = info[UIImagePickerControllerOriginalImage] as? UIImage else { return }
 let fixedImage = originalImage.fixedOrientation()
 // do your work
}
</code></pre>

blocks|key|739638|text|我遇到过这个问题，从相机拍摄的图像或保存在相机胶卷中的图像是从相机拍摄的。从safari浏览器下载的照片库中的图像在上传时不旋转。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739639|我能够通过在上传之前将图像数据转换为JPEG格式来解决这个问题。|739640|let+image+=+info[UIImagePickerControllerOriginalImage]+as!+UIImage++++++++
let+data+=+UIImageJPEGRepresentation(image,+1.0)|code-block|syntax|javascript|739641|我们现在可以使用数据进行上传，图像在上传后不会旋转。|739642|希望这能行得通。|739643|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I have experienced this issue with images taken from camera or saved in camera roll which are taken from camera. Images downloaded in photo library from safari browser does not rotate when uploaded.

I was able to solve this issue by making the image data as JPEG before uploading.

<pre><code>let image = info[UIImagePickerControllerOriginalImage] as! UIImage 
let data = UIImageJPEGRepresentation(image, 1.0)
</code></pre>

We can now use the data for uploading and the image will not get rotated after upload.

Hope this will work.

blocks|key|955547|text|@an0解决方案的Swift+4.x/5.0版本：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|955548|extension+UIImage+{
++++func+upOrientationImage()+->+UIImage?+{
++++++++switch+imageOrientation+{
++++++++case+.up:
++++++++++++return+self
++++++++default:
++++++++++++UIGraphicsBeginImageContextWithOptions(size,+false,+scale)
++++++++++++draw(in:+CGRect(origin:+.zero,+size:+size))
++++++++++++let+result+=+UIGraphicsGetImageFromCurrentImageContext()
++++++++++++UIGraphicsEndImageContext()
++++++++++++return+result
++++++++}
++++}
}|code-block|syntax|javascript|955549|entityMap^0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Swift 4.x/5.0 version of <code>@an0</code> 's solution:

<pre><code>extension UIImage {
 func upOrientationImage() -&gt; UIImage? {
 switch imageOrientation {
 case .up:
 return self
 default:
 UIGraphicsBeginImageContextWithOptions(size, false, scale)
 draw(in: CGRect(origin: .zero, size: size))
 let result = UIGraphicsGetImageFromCurrentImageContext()
 UIGraphicsEndImageContext()
 return result
 }
 }
}
</code></pre>

blocks|key|955562|text|@an0,+thanks+for+the+answer!
The+only+thing+is+autoreleasepool:+

func+fixOrientation(img:+UIImage)+->+UIImage?+{

++++let+result:+UIImage?
++++if+img.imageOrientation+==+.up+{
++++++++result+=+img
++++}+else+{

++++++++result+=+autoreleasepool+{+()+->+UIImage?+in
++++++++++++UIGraphicsBeginImageContextWithOptions(img.size,+false,+img.scale)
++++++++++++let+rect+=+CGRect(x:+0,+y:+0,+width:+img.size.width,+height:+img.size.height)
++++++++++++img.draw(in:+rect)

++++++++++++let+normalizedImage+=+UIGraphicsGetImageFromCurrentImageContext()
++++++++++++UIGraphicsEndImageContext()

++++++++++++return+normalizedImage
++++++++}
++++}

++++return+result
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|955563|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>@an0, thanks for the answer!
The only thing is autoreleasepool: 

func fixOrientation(img: UIImage) -&gt; UIImage? {

 let result: UIImage?
 if img.imageOrientation == .up {
 result = img
 } else {

 result = autoreleasepool { () -&gt; UIImage? in
 UIGraphicsBeginImageContextWithOptions(img.size, false, img.scale)
 let rect = CGRect(x: 0, y: 0, width: img.size.width, height: img.size.height)
 img.draw(in: rect)

 let normalizedImage = UIGraphicsGetImageFromCurrentImageContext()
 UIGraphicsEndImageContext()

 return normalizedImage
 }
 }

 return result
}
</code></pre>

blocks|key|955621|text|以下是用于自动修复图像方向返回UIImage的Swift-4.2代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|955622|func+AutofixImageOrientation(_+image:+UIImage)->UIImage+{

++++UIGraphicsBeginImageContext(image.size)

++++image.draw(at:+.zero)

++++let+newImage+=+UIGraphicsGetImageFromCurrentImageContext()

++++UIGraphicsEndImageContext()

++++return+newImage+??+image
}|code-block|syntax|javascript|955623|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the Swift-4.2 code for automatic fix your image orientation
Returns UIImage

<pre><code>func AutofixImageOrientation(_ image: UIImage)-&gt;UIImage {

 UIGraphicsBeginImageContext(image.size)

 image.draw(at: .zero)

 let newImage = UIGraphicsGetImageFromCurrentImageContext()

 UIGraphicsEndImageContext()

 return newImage ?? image
}
</code></pre>

blocks|key|739786|text|我把这段代码换成了Xamarin：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|739787|private+static+UIImage+FixImageOrientation(UIImage+image)
++++{
++++++++if+(image.Orientation+==+UIImageOrientation.Up)
++++++++{
++++++++++++return+image;
++++++++}

++++++++var+transform+=+CGAffineTransform.MakeIdentity();

++++++++float+pi+=+(float)Math.PI;

++++++++switch+(image.Orientation)
++++++++{
++++++++++++case+UIImageOrientation.Down:
++++++++++++case+UIImageOrientation.DownMirrored:
++++++++++++++++transform+=+CGAffineTransform.Translate(transform,+image.Size.Width,+image.Size.Height);
++++++++++++++++transform+=+CGAffineTransform.Rotate(transform,+pi);
++++++++++++++++break;

++++++++++++case+UIImageOrientation.Left:
++++++++++++case+UIImageOrientation.LeftMirrored:
++++++++++++++++transform+=+CGAffineTransform.Translate(transform,+image.Size.Width,+0);
++++++++++++++++transform+=+CGAffineTransform.Rotate(transform,+pi+/+2);
++++++++++++++++break;

++++++++++++case+UIImageOrientation.Right:
++++++++++++case+UIImageOrientation.RightMirrored:
++++++++++++++++transform+=+CGAffineTransform.Translate(transform,+0,+image.Size.Height);
++++++++++++++++transform+=+CGAffineTransform.Rotate(transform,+-(pi+/+2));
++++++++++++++++break;
++++++++}

++++++++switch+(image.Orientation)
++++++++{
++++++++++++case+UIImageOrientation.UpMirrored:
++++++++++++case+UIImageOrientation.DownMirrored:
++++++++++++++++transform+=+CGAffineTransform.Translate(transform,+image.Size.Width,+0);
++++++++++++++++transform+=+CGAffineTransform.Scale(transform,+-1,+1);
++++++++++++++++break;

++++++++++++case+UIImageOrientation.LeftMirrored:
++++++++++++case+UIImageOrientation.RightMirrored:
++++++++++++++++transform+=+CGAffineTransform.Translate(transform,+image.Size.Height,+0);
++++++++++++++++transform+=+CGAffineTransform.Scale(transform,+-1,+1);
++++++++++++++++break;
++++++++}

++++++++var+ctx+=+new+CGBitmapContext(null,+(nint)image.Size.Width,+(nint)image.Size.Height,+image.CGImage.BitsPerComponent,
++++++++++++image.CGImage.BytesPerRow,+image.CGImage.ColorSpace,+image.CGImage.BitmapInfo);

++++++++ctx.ConcatCTM(transform);

++++++++switch+(image.Orientation)
++++++++{
++++++++++++case+UIImageOrientation.Left:
++++++++++++case+UIImageOrientation.LeftMirrored:
++++++++++++case+UIImageOrientation.Right:
++++++++++++case+UIImageOrientation.RightMirrored:
++++++++++++++++ctx.DrawImage(new+CGRect(0,+0,+image.Size.Height,+image.Size.Width),+image.CGImage);
++++++++++++++++break;

++++++++++++default:
++++++++++++++++ctx.DrawImage(new+CGRect(0,+0,+image.Size.Width,+image.Size.Height),+image.CGImage);
++++++++++++++++break;
++++++++}

++++++++var+cgimg+=+ctx.ToImage();
++++++++var+img+=+new+UIImage(cgimg);

++++++++ctx.Dispose();
++++++++ctx+=+null;
++++++++cgimg.Dispose();
++++++++cgimg+=+null;

++++++++return+img;
++++}|code-block|syntax|javascript|739788|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I transposed this into Xamarin:

<pre><code>private static UIImage FixImageOrientation(UIImage image)
 {
 if (image.Orientation == UIImageOrientation.Up)
 {
 return image;
 }

 var transform = CGAffineTransform.MakeIdentity();

 float pi = (float)Math.PI;

 switch (image.Orientation)
 {
 case UIImageOrientation.Down:
 case UIImageOrientation.DownMirrored:
 transform = CGAffineTransform.Translate(transform, image.Size.Width, image.Size.Height);
 transform = CGAffineTransform.Rotate(transform, pi);
 break;

 case UIImageOrientation.Left:
 case UIImageOrientation.LeftMirrored:
 transform = CGAffineTransform.Translate(transform, image.Size.Width, 0);
 transform = CGAffineTransform.Rotate(transform, pi / 2);
 break;

 case UIImageOrientation.Right:
 case UIImageOrientation.RightMirrored:
 transform = CGAffineTransform.Translate(transform, 0, image.Size.Height);
 transform = CGAffineTransform.Rotate(transform, -(pi / 2));
 break;
 }

 switch (image.Orientation)
 {
 case UIImageOrientation.UpMirrored:
 case UIImageOrientation.DownMirrored:
 transform = CGAffineTransform.Translate(transform, image.Size.Width, 0);
 transform = CGAffineTransform.Scale(transform, -1, 1);
 break;

 case UIImageOrientation.LeftMirrored:
 case UIImageOrientation.RightMirrored:
 transform = CGAffineTransform.Translate(transform, image.Size.Height, 0);
 transform = CGAffineTransform.Scale(transform, -1, 1);
 break;
 }

 var ctx = new CGBitmapContext(null, (nint)image.Size.Width, (nint)image.Size.Height, image.CGImage.BitsPerComponent,
 image.CGImage.BytesPerRow, image.CGImage.ColorSpace, image.CGImage.BitmapInfo);

 ctx.ConcatCTM(transform);

 switch (image.Orientation)
 {
 case UIImageOrientation.Left:
 case UIImageOrientation.LeftMirrored:
 case UIImageOrientation.Right:
 case UIImageOrientation.RightMirrored:
 ctx.DrawImage(new CGRect(0, 0, image.Size.Height, image.Size.Width), image.CGImage);
 break;

 default:
 ctx.DrawImage(new CGRect(0, 0, image.Size.Width, image.Size.Height), image.CGImage);
 break;
 }

 var cgimg = ctx.ToImage();
 var img = new UIImage(cgimg);

 ctx.Dispose();
 ctx = null;
 cgimg.Dispose();
 cgimg = null;

 return img;
 }
</code></pre>

blocks|key|955732|text|我通过编写以下几行代码来实现这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|955733|extension+UIImage+{

++++public+func+correctlyOrientedImage()+->+UIImage+{
++++++++guard+imageOrientation+!=+.up+else+{+return+self+}

++++++++UIGraphicsBeginImageContextWithOptions(size,+false,+scale)
++++++++draw(in:+CGRect(origin:+.zero,+size:+size))
++++++++let+normalizedImage:+UIImage+=+UIGraphicsGetImageFromCurrentImageContext()!
++++++++UIGraphicsEndImageContext()

++++++++return+normalizedImage
++++}
}|code-block|syntax|javascript|955734|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I achieve this by writing below a few lines of code
<pre class="lang-swift prettyprint-override"><code>extension UIImage {

 public func correctlyOrientedImage() -&gt; UIImage {
 guard imageOrientation != .up else { return self }

 UIGraphicsBeginImageContextWithOptions(size, false, scale)
 draw(in: CGRect(origin: .zero, size: size))
 let normalizedImage: UIImage = UIGraphicsGetImageFromCurrentImageContext()!
 UIGraphicsEndImageContext()

 return normalizedImage
 }
}
</code></pre>

I am testing my iPhone application on an iOS 3.1.3 iPhone. I am selecting/capturing an image using a <code>UIImagePickerController</code>:

<pre><code>UIImagePickerController *imagePicker = [[UIImagePickerController alloc] init];
[imagePicker setSourceType:UIImagePickerControllerSourceTypeCamera];
[imagePicker setDelegate:self];
[self.navigationController presentModalViewController:imagePicker animated:YES];
[imagePicker release];



- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info {
 self.image = [info objectForKey:UIImagePickerControllerOriginalImage];
 imageView.image = self.image;
 [self.navigationController dismissModalViewControllerAnimated:YES];
 submitButton.enabled = YES;
}
</code></pre>

I then at some point send it to my web server using the ASI classes:

<pre><code>ASIFormDataRequest *request = [ASIFormDataRequest requestWithURL:[NSURL URLWithString:@"http://example.com/myscript.php"]];
[request setDelegate:self];
[request setStringEncoding:NSUTF8StringEncoding];
[request setShouldContinueWhenAppEntersBackground:YES];
//other post keys/values
[request setFile:UIImageJPEGRepresentation(self.image, 100.0f) withFileName:[NSString stringWithFormat:@"%d.jpg", [[NSDate date] timeIntervalSinceNow]] andContentType:@"image/jpg" forKey:@"imageFile"];
[request startAsynchronous];
</code></pre>

the problem:
when i take a picture with the iphone while holding it landscape, the image gets uploaded to the server and it viewed like you would expect. when taking a picture holding the phone in portrait, the image is uploaded and viewed as it had been rotated 90 degrees.

my application is set to only work in portrait modes(upsidedown and regular).

How can i make the image always show the correct orientation after uploading?

the image appears to be correct as displayed in an UIImageView(directly after taking the picture), but viewing on the server says otherwise.

iOS UIImagePickerController result image orientation after upload

数据转换

服务器

Xamarin

Swift

我正在iOS 3.1.3 iPhone上测试我的iPhone应用程序。我正在使用UIImagePickerController选择/捕获图像UIImagePickerController *imagePicker = [[UIImagePickerController alloc] init];[imagePicker...

问上传后的iOS UIImagePickerController结果图像方向
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问上传后的iOS UIImagePickerController结果图像方向EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问上传后的iOS UIImagePickerController结果图像方向
EN