Introduction

If CGContextDrawImage draws a UIImage.CGImage upside down, the usual cause is a coordinate-system mismatch. Core Graphics draws with an origin at the bottom-left by default, while UIKit works with an origin at the top-left, so a UIImage that looks correct in UIKit can appear flipped when drawn directly through Core Graphics.

Why the image flips

UIImage is a UIKit type. CGImage is a lower-level Core Graphics representation. When you pass image.CGImage into CGContextDrawImage, Core Graphics uses its own coordinate assumptions, not UIKit’s.

That means code like this often produces an upside-down image:

1import UIKit
2
3func draw(_ image: UIImage, in context: CGContext, rect: CGRect) {
4    context.draw(image.cgImage!, in: rect)
5}

The image data itself is not necessarily wrong. The problem is how the context interprets the coordinate system.

Fix it by flipping the context

The standard fix is to translate and scale the context before drawing.

1import UIKit
2
3func drawCorrectly(_ image: UIImage, in context: CGContext, rect: CGRect) {
4    guard let cgImage = image.cgImage else { return }
5
6    context.saveGState()
7    context.translateBy(x: 0, y: rect.maxY)
8    context.scaleBy(x: 1, y: -1)
9    context.draw(cgImage, in: CGRect(x: rect.minX, y: 0, width: rect.width, height: rect.height))
10    context.restoreGState()
11}

The vertical scale of -1 flips the drawing space, and the translation moves the origin so the image lands in the expected place.

Use UIImage.draw(in:) when you want UIKit behavior

If you are already in UIKit drawing code and do not need low-level Core Graphics behavior, the simpler option is often to let UIImage draw itself.

1import UIKit
2
3func drawUsingUIKit(_ image: UIImage, rect: CGRect) {
4    image.draw(in: rect)
5}

UIImage.draw(in:) respects UIKit’s coordinate conventions and also handles UIImage orientation metadata more naturally.

Watch out for image orientation

Another wrinkle is that UIImage can carry orientation information that CGImage does not preserve in the same high-level way. If the image came from the camera or photo library, image.imageOrientation may not be .up.

If you draw the raw CGImage, you may need to normalize orientation first.

1import UIKit
2
3func normalizedImage(_ image: UIImage) -> UIImage {
4    if image.imageOrientation == .up {
5        return image
6    }
7
8    UIGraphicsBeginImageContextWithOptions(image.size, false, image.scale)
9    image.draw(in: CGRect(origin: .zero, size: image.size))
10    let normalized = UIGraphicsGetImageFromCurrentImageContext()
11    UIGraphicsEndImageContext()
12    return normalized ?? image
13}

This does not replace the coordinate flip in every case, but it solves a related class of orientation surprises.

When direct Core Graphics drawing still makes sense

You may still want CGContextDrawImage when:

• composing into a bitmap context
• applying low-level transforms
• mixing vector and bitmap drawing manually
• generating offscreen images

In those cases, it is worth understanding the coordinate system rather than relying on higher-level UIKit drawing helpers.

A complete bitmap-context example

1import UIKit
2
3func renderedCopy(from image: UIImage) -> UIImage? {
4    guard let cgImage = image.cgImage else { return nil }
5
6    let size = image.size
7    UIGraphicsBeginImageContextWithOptions(size, false, image.scale)
8    guard let context = UIGraphicsGetCurrentContext() else {
9        UIGraphicsEndImageContext()
10        return nil
11    }
12
13    context.translateBy(x: 0, y: size.height)
14    context.scaleBy(x: 1, y: -1)
15    context.draw(cgImage, in: CGRect(origin: .zero, size: size))
16
17    let output = UIGraphicsGetImageFromCurrentImageContext()
18    UIGraphicsEndImageContext()
19    return output
20}

This creates a new image with the expected visual orientation in UIKit.

Common Pitfalls

The biggest mistake is assuming UIImage and CGImage share the same drawing conventions. They do not. UIKit and Core Graphics use different coordinate assumptions.

Another issue is applying the flip transform but forgetting to restore the graphics state. That can cause later drawing operations to inherit the flipped coordinate system unexpectedly.

Developers also confuse vertical coordinate flipping with UIImage orientation metadata. These are related but separate concerns. A camera image can have orientation issues even after the context itself is corrected.

Finally, if you only need ordinary UIKit drawing, do not force everything through CGContextDrawImage. UIImage.draw(in:) is often the simpler and safer API.

Summary

• 'CGContextDrawImage uses Core Graphics coordinates, which differ from UIKit coordinates.'
• A UIImage.CGImage often appears upside down unless you flip the context first.
• Use translateBy and scaleBy to correct the drawing space.
• 'UIImage.draw(in:) is simpler when you want UIKit-friendly behavior.'
• Image-orientation metadata can create additional issues beyond the basic upside-down rendering problem.