Implement Image.withCGImage(_:)

Author: koher

Sources/EasyImagy/ImageCoreGraphics.swift

@@ -332,6 +332,15 @@
                 bitmapInfo: Image<UInt8>.bitmapInfo
             )
         }
+
+        public func withCGImage<R>(_ body: (CGImage) throws -> R) rethrows -> R {
+            return try Image.withGeneratedCGImage(
+                image: self,
+                colorSpace: Image<UInt8>.colorSpace,
+                bitmapInfo: Image<UInt8>.bitmapInfo,
+                body: body
+            )
+        }
     }
 
     extension Image where Pixel == UInt16 {
@@ -373,6 +382,15 @@
                 bitmapInfo: Image<UInt16>.bitmapInfo
             )
         }
+
+        public func withCGImage<R>(_ body: (CGImage) throws -> R) rethrows -> R {
+            return try Image.withGeneratedCGImage(
+                image: self,
+                colorSpace: Image<UInt16>.colorSpace,
+                bitmapInfo: Image<UInt16>.bitmapInfo,
+                body: body
+            )
+        }
     }
 
     extension Image where Pixel == UInt32 {
@@ -414,6 +432,15 @@
                 bitmapInfo: Image<UInt32>.bitmapInfo
             )
         }
+
+        public func withCGImage<R>(_ body: (CGImage) throws -> R) rethrows -> R {
+            return try Image.withGeneratedCGImage(
+                image: self,
+                colorSpace: Image<UInt32>.colorSpace,
+                bitmapInfo: Image<UInt32>.bitmapInfo,
+                body: body
+            )
+        }
     }
 
     extension Image where Pixel == Float {

Sources/EasyImagy/ImageCoreGraphics.swift.gyb

@@ -198,6 +198,15 @@
                 bitmapInfo: Image<${type}>.bitmapInfo
             )
         }
+
+        public func withCGImage<R>(_ body: (CGImage) throws -> R) rethrows -> R {
+            return try Image.withGeneratedCGImage(
+                image: self,
+                colorSpace: Image<${type}>.colorSpace,
+                bitmapInfo: Image<${type}>.bitmapInfo,
+                body: body
+            )
+        }
     }
 % end
 %

Sources/EasyImagy/ImageInternal.swift

@@ -173,7 +173,47 @@ extension Image { // Gray
             intent: CGColorRenderingIntent.defaultIntent
         )!
     }
-
+    
+    internal static func withGeneratedCGImage<R, Pixel>(
+        image: Image<Pixel>,
+        colorSpace: CGColorSpace,
+        bitmapInfo: CGBitmapInfo,
+        body: (CGImage) throws -> R
+    ) rethrows -> R {
+        var image = image
+        let bytesPerPixel = MemoryLayout<Pixel>.size
+        let length = image.count * bytesPerPixel
+        let width = image.width
+        let height = image.height
+        
+        return try image.pixels.withUnsafeMutableBytes { bytes in
+            let provider: CGDataProvider = CGDataProvider(data: Data(
+                bytesNoCopy: bytes.baseAddress!,
+                    // `baseAddress` is `nil` if `bytes.count` is `0`.
+                    // However creating a `CGImage` with 0 pixels is illegal.
+                    // So calling this method with empty images are logic failures
+                    // and using `!` is justified.
+                count: length,
+                deallocator: .none
+            ) as CFData)!
+            
+            let cgImage = CGImage(
+                width: width,
+                height: height,
+                bitsPerComponent: bytesPerPixel * 8,
+                bitsPerPixel: bytesPerPixel * 8,
+                bytesPerRow: bytesPerPixel * width,
+                space: colorSpace,
+                bitmapInfo: bitmapInfo,
+                provider: provider,
+                decode: nil,
+                shouldInterpolate: false,
+                intent: CGColorRenderingIntent.defaultIntent
+            )!
+            
+            return try body(cgImage)
+        }
+    }
 }
 
 #endif

Tests/EasyImagyTests/ImageCoreGraphicsTest.swift

@@ -95,6 +95,28 @@ import EasyImagy
                 XCTAssertEqual(restored, image)
             }
         }
+        
+        func testWithCGImage() {
+            let image = Image<UInt8>(width: 3, height: 2, pixels: [
+                1, 2, 3,
+                4, 5, 6,
+            ])
+            
+            image.withCGImage { cgImage in
+                let restored = Image<UInt8>(cgImage: cgImage)
+                
+                XCTAssertEqual(restored.width, 3)
+                XCTAssertEqual(restored.height, 2)
+                
+                XCTAssertEqual(restored[0, 0], 1)
+                XCTAssertEqual(restored[1, 0], 2)
+                XCTAssertEqual(restored[2, 0], 3)
+                
+                XCTAssertEqual(restored[0, 1], 4)
+                XCTAssertEqual(restored[1, 1], 5)
+                XCTAssertEqual(restored[2, 1], 6)
+            }
+        }
     }
 
 #endif