Refactors and improves Image class structure

Improves code organization by using extensions for logical groupings of image operations.

Adds deinitializer to properly release allocated memory, preventing memory leaks.

Author: brillcp

Sources/SwiftLibgd/Image.swift

@@ -8,12 +8,14 @@ import Foundation
 import gd
 
 public class Image {
+    // MARK: Private properties
+    private var internalImage: gdImagePtr
+
+    // MARK: - Public properties
     public enum FlipMode {
         case horizontal, vertical, both
     }
 
-    private var internalImage: gdImagePtr
-
     public var size: Size {
         Size(width: internalImage.pointee.sx, height: internalImage.pointee.sy)
     }
@@ -25,6 +27,7 @@ public class Image {
         }
     }
 
+    // MARK: - Init
     public init?(width: Int, height: Int) {
         internalImage = gdImageCreateTrueColor(Int32(width), Int32(height))
     }
@@ -39,8 +42,8 @@ public class Image {
 
         let ext = url.lastPathComponent.lowercased()
         let img: gdImagePtr? = ext.hasSuffix("jpg") || ext.hasSuffix("jpeg")
-            ? gdImageCreateFromJpeg(file)
-            : ext.hasSuffix("png") ? gdImageCreateFromPng(file) : nil
+        ? gdImageCreateFromJpeg(file)
+        : ext.hasSuffix("png") ? gdImageCreateFromPng(file) : nil
 
         guard let loadedImage = img else { return nil }
         self.init(gdImage: loadedImage)
@@ -50,55 +53,62 @@ public class Image {
         try self.init(gdImage: format.imagePtr(of: data))
     }
 
-    // MARK: - Transform Operations
+    // MARK: - Deinit
+    deinit {
+        gdImageDestroy(internalImage)
+    }
+}
 
-    public func cloned() -> Image? {
+// MARK: - Transform Operations
+public extension Image {
+    func cloned() -> Image? {
         gdImageClone(internalImage).map { Image(gdImage: $0) }
     }
 
-    public func resizedTo(width: Int, height: Int, smooth: Bool = true) -> Image? {
+    func resizedTo(width: Int, height: Int, smooth: Bool = true) -> Image? {
         setInterpolation(smooth: smooth, from: size, to: Size(width: width, height: height))
         return gdImageScale(internalImage, UInt32(width), UInt32(height)).map { Image(gdImage: $0) }
     }
 
-    public func resizedTo(width: Int, smooth: Bool = true) -> Image? {
+    func resizedTo(width: Int, smooth: Bool = true) -> Image? {
         let ratio = Double(width) / Double(size.width)
         let newHeight = Int32(Double(size.height) * ratio)
         return resizedTo(width: width, height: Int(newHeight), smooth: smooth)
     }
 
-    public func resizedTo(height: Int, smooth: Bool = true) -> Image? {
+    func resizedTo(height: Int, smooth: Bool = true) -> Image? {
         let ratio = Double(height) / Double(size.height)
         let newWidth = Int32(Double(size.width) * ratio)
         return resizedTo(width: Int(newWidth), height: height, smooth: smooth)
     }
 
-    public func cropped(to rect: Rectangle) -> Image? {
+    func cropped(to rect: Rectangle) -> Image? {
         var r = gdRect(x: Int32(rect.point.x), y: Int32(rect.point.y),
                        width: Int32(rect.size.width), height: Int32(rect.size.height))
         return gdImageCrop(internalImage, &r).map { Image(gdImage: $0) }
     }
 
-    public func rotated(_ angle: Angle) -> Image? {
+    func rotated(_ angle: Angle) -> Image? {
         gdImageRotateInterpolated(internalImage, Float(angle.degrees), 0).map { Image(gdImage: $0) }
     }
 
-    public func flipped(_ mode: FlipMode) -> Image? {
+    func flipped(_ mode: FlipMode) -> Image? {
         guard let copy = gdImageClone(internalImage) else { return nil }
         applyFlip(to: copy, mode: mode)
         return Image(gdImage: copy)
     }
 
-    public func flip(_ mode: FlipMode) {
+    func flip(_ mode: FlipMode) {
         applyFlip(to: internalImage, mode: mode)
     }
+}
 
-    // MARK: - Drawing Operations
-
+// MARK: - Drawing Operations
+public extension Image {
     @MainActor
-    public func renderText(_ text: String, from: Point, fontList: [String],
-                          color: Color, size: Double, angle: Angle = .zero)
-        -> (upperLeft: Point, upperRight: Point, lowerRight: Point, lowerLeft: Point) {
+    func renderText(_ text: String, from: Point, fontList: [String],
+                    color: Color, size: Double, angle: Angle = .zero)
+    -> (upperLeft: Point, upperRight: Point, lowerRight: Point, lowerLeft: Point) {
         guard !text.isEmpty, !fontList.isEmpty,
               var textCChar = text.cString(using: .utf8),
               var fonts = fontList.joined(separator: ";").cString(using: .utf8) else {
@@ -110,106 +120,132 @@ public class Image {
 
         var box: [Int32] = .init(repeating: 0, count: 8)
         gdImageStringFT(internalImage, &box, c, &fonts, size, -angle.radians,
-                       Int32(from.x), Int32(from.y), &textCChar)
+                        Int32(from.x), Int32(from.y), &textCChar)
 
         return (Point(x: box[6], y: box[7]), Point(x: box[4], y: box[5]),
                 Point(x: box[2], y: box[3]), Point(x: box[0], y: box[1]))
     }
 
-    public func fill(from: Point, color: Color) {
+    func fill(from: Point, color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
         gdImageFill(internalImage, Int32(from.x), Int32(from.y), c)
     }
 
-    public func drawLine(from: Point, to: Point, color: Color) {
+    func drawLine(from: Point, to: Point, color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
         gdImageLine(internalImage, Int32(from.x), Int32(from.y), Int32(to.x), Int32(to.y), c)
     }
 
     @MainActor
-    public func drawImage(_ image: Image, at topLeft: Point = .zero) {
+    func drawImage(_ image: Image, at topLeft: Point = .zero) {
         gdImageCopy(internalImage, image.internalImage,
-                   Int32(topLeft.x), Int32(topLeft.y), 0, 0,
-                   Int32(size.width - topLeft.x), Int32(size.height - topLeft.y))
+                    Int32(topLeft.x), Int32(topLeft.y), 0, 0,
+                    Int32(size.width - topLeft.x), Int32(size.height - topLeft.y))
     }
 
-    public func set(pixel: Point, to color: Color) {
+    func set(pixel: Point, to color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
         gdImageSetPixel(internalImage, Int32(pixel.x), Int32(pixel.y), c)
     }
 
-    public func get(pixel: Point) -> Color {
+    func get(pixel: Point) -> Color {
         let c = gdImageGetTrueColorPixel(internalImage, Int32(pixel.x), Int32(pixel.y))
         return Color(red: Double((c >> 16) & 0xFF) / 255,
-                    green: Double((c >> 8) & 0xFF) / 255,
-                    blue: Double(c & 0xFF) / 255,
-                    alpha: 1 - Double((c >> 24) & 0xFF) / 127)
+                     green: Double((c >> 8) & 0xFF) / 255,
+                     blue: Double(c & 0xFF) / 255,
+                     alpha: 1 - Double((c >> 24) & 0xFF) / 127)
     }
 
-    public func strokeEllipse(center: Point, size: Size, color: Color) {
+    func strokeEllipse(center: Point, size: Size, color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
-        gdImageEllipse(internalImage, Int32(center.x), Int32(center.y),
-                      Int32(size.width), Int32(size.height), c)
+        gdImageEllipse(
+            internalImage,
+            Int32(center.x),
+            Int32(center.y),
+            Int32(size.width),
+            Int32(size.height),
+            c
+        )
     }
 
-    public func fillEllipse(center: Point, size: Size, color: Color) {
+    func fillEllipse(center: Point, size: Size, color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
-        gdImageFilledEllipse(internalImage, Int32(center.x), Int32(center.y),
-                           Int32(size.width), Int32(size.height), c)
+        gdImageFilledEllipse(
+            internalImage,
+            Int32(center.x),
+            Int32(center.y),
+            Int32(size.width),
+            Int32(size.height),
+            c
+        )
     }
 
-    public func strokeRectangle(topLeft: Point, bottomRight: Point, color: Color) {
+    func strokeRectangle(topLeft: Point, bottomRight: Point, color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
-        gdImageRectangle(internalImage, Int32(topLeft.x), Int32(topLeft.y),
-                        Int32(bottomRight.x), Int32(bottomRight.y), c)
+        gdImageRectangle(
+            internalImage,
+            Int32(topLeft.x),
+            Int32(topLeft.y),
+            Int32(bottomRight.x),
+            Int32(bottomRight.y),
+            c
+        )
     }
 
-    public func fillRectangle(topLeft: Point, bottomRight: Point, color: Color) {
+    func fillRectangle(topLeft: Point, bottomRight: Point, color: Color) {
         let c = allocateColor(color)
         defer { gdImageColorDeallocate(internalImage, c) }
-        gdImageFilledRectangle(internalImage, Int32(topLeft.x), Int32(topLeft.y),
-                             Int32(bottomRight.x), Int32(bottomRight.y), c)
+        gdImageFilledRectangle(
+            internalImage,
+            Int32(topLeft.x),
+            Int32(topLeft.y),
+            Int32(bottomRight.x),
+            Int32(bottomRight.y),
+            c
+        )
     }
+}
 
-    // MARK: - Effects
-
-    public func pixelate(blockSize: Int) {
+// MARK: - Effects
+public extension Image {
+    func pixelate(blockSize: Int) {
         gdImagePixelate(internalImage, Int32(blockSize), GD_PIXELATE_AVERAGE.rawValue)
     }
 
-    public func blur(radius: Int) {
+    func blur(radius: Int) {
         if let result = gdImageCopyGaussianBlurred(internalImage, Int32(radius), -1) {
             gdImageDestroy(internalImage)
             internalImage = result
         }
     }
 
-    public func colorize(using color: Color) {
+    func colorize(using color: Color) {
         let c = colorComponents(color)
         gdImageColor(internalImage, c.0, c.1, c.2, c.3)
     }
 
-    public func desaturate() {
+    func desaturate() {
         gdImageGrayScale(internalImage)
     }
 
-    public func reduceColors(max numberOfColors: Int, dither: Bool = true) throws {
+    func reduceColors(max numberOfColors: Int, dither: Bool = true) throws {
         guard numberOfColors > 1 else {
             throw Error.invalidMaxColors(reason: "Indexed images must have at least 2 colors")
         }
         gdImageTrueColorToPalette(internalImage, dither ? 1 : 0, Int32(numberOfColors))
     }
+}
 
-    // MARK: - Export
-
+// MARK: - Export
+public extension Image {
     @discardableResult
-    public func write(to url: URL, quality: Int = 100, allowOverwrite: Bool = false) -> Bool {
+    func write(to url: URL, quality: Int = 100, allowOverwrite: Bool = false) -> Bool {
         let ext = url.pathExtension.lowercased()
         guard ext == "png" || ext == "jpeg" || ext == "jpg" else { return false }
         guard allowOverwrite || !FileManager.default.fileExists(atPath: url.path) else { return false }
@@ -226,23 +262,24 @@ public class Image {
         return FileManager.default.fileExists(atPath: url.path)
     }
 
-    public func export(as format: ExportableFormat = .png) throws -> Data {
+    func export(as format: ExportableFormat = .png) throws -> Data {
         try format.data(of: internalImage)
     }
+}
 
-    // MARK: - Private Helpers
-
-    private func allocateColor(_ color: Color) -> Int32 {
+// MARK: - Private Helpers
+private extension Image {
+    func allocateColor(_ color: Color) -> Int32 {
         let c = colorComponents(color)
         return gdImageColorAllocateAlpha(internalImage, c.0, c.1, c.2, c.3)
     }
 
-    private func colorComponents(_ color: Color) -> (Int32, Int32, Int32, Int32) {
+    func colorComponents(_ color: Color) -> (Int32, Int32, Int32, Int32) {
         (Int32(color.redComponent * 255), Int32(color.greenComponent * 255),
          Int32(color.blueComponent * 255), 127 - Int32(color.alphaComponent * 127))
     }
 
-    private func setInterpolation(smooth: Bool, from: Size, to: Size) {
+    func setInterpolation(smooth: Bool, from: Size, to: Size) {
         guard smooth else {
             gdImageSetInterpolationMethod(internalImage, GD_NEAREST_NEIGHBOUR)
             return
@@ -251,15 +288,11 @@ public class Image {
         gdImageSetInterpolationMethod(internalImage, method)
     }
 
-    private func applyFlip(to image: gdImagePtr, mode: FlipMode) {
+    func applyFlip(to image: gdImagePtr, mode: FlipMode) {
         switch mode {
         case .horizontal: gdImageFlipHorizontal(image)
         case .vertical: gdImageFlipVertical(image)
         case .both: gdImageFlipBoth(image)
         }
     }
-
-    deinit {
-        gdImageDestroy(internalImage)
-    }
 }