@simasfin/smmf-sdk 0.0.0-stage → 0.2.3

package/ios/OnePassSDK/Ocr/CoverFitCrop.swift

@@ -0,0 +1,37 @@
+import CoreGraphics
+import Foundation
+
+public struct CropRegion: Equatable {
+    public let left: Int
+    public let top: Int
+    public let width: Int
+    public let height: Int
+}
+
+public enum CoverFitCrop {
+    public static func compute(
+        photoWidth: Int,
+        photoHeight: Int,
+        displayWidth: Int,
+        displayHeight: Int,
+        frame: CGRect
+    ) -> CropRegion {
+        let displayAspect = Float(displayWidth) / Float(displayHeight)
+        let photoAspect = Float(photoWidth) / Float(photoHeight)
+        let scale: Float
+        var offsetX: Float = 0
+        var offsetY: Float = 0
+        if photoAspect > displayAspect {
+            scale = Float(photoHeight) / Float(displayHeight)
+            offsetX = (Float(photoWidth) - Float(displayWidth) * scale) / 2
+        } else {
+            scale = Float(photoWidth) / Float(displayWidth)
+            offsetY = (Float(photoHeight) - Float(displayHeight) * scale) / 2
+        }
+        let left = max(0, Int((offsetX + Float(frame.minX) * scale).rounded()))
+        let top = max(0, Int((offsetY + Float(frame.minY) * scale).rounded()))
+        let width = max(1, min(Int((Float(frame.width) * scale).rounded()), photoWidth - left))
+        let height = max(1, min(Int((Float(frame.height) * scale).rounded()), photoHeight - top))
+        return CropRegion(left: left, top: top, width: width, height: height)
+    }
+}

package/ios/OnePassSDK/Ocr/KtpFrameOverlayView.swift

@@ -0,0 +1,98 @@
+import UIKit
+
+final class KtpFrameOverlayView: UIView {
+
+    static let frameRatio: CGFloat = 1.586
+    private static let frameWidthFraction: CGFloat = 0.85
+    private static let cornerSize: CGFloat = 24
+    private static let cornerBorder: CGFloat = 3
+    private static let frameRadius: CGFloat = 12
+    private static let guideWidthFraction: CGFloat = 0.3
+    private static let guideRadius: CGFloat = 4
+
+    var frameRect: CGRect {
+        let width = bounds.width * Self.frameWidthFraction
+        let height = width / Self.frameRatio
+        return CGRect(
+            x: (bounds.width - width) / 2,
+            y: (bounds.height - height) / 2,
+            width: width,
+            height: height
+        )
+    }
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .clear
+        isUserInteractionEnabled = false
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("tidak dipakai") }
+
+    override func draw(_ rect: CGRect) {
+        guard let context = UIGraphicsGetCurrentContext() else { return }
+        let frame = frameRect
+
+        UIColor.black.withAlphaComponent(0.5).setFill()
+        context.fill(bounds)
+        let hole = UIBezierPath(roundedRect: frame, cornerRadius: Self.frameRadius)
+        context.setBlendMode(.clear)
+        hole.fill()
+        context.setBlendMode(.normal)
+
+        UIColor.white.withAlphaComponent(0.3).setStroke()
+        hole.lineWidth = 1
+        hole.stroke()
+
+        drawCorners(in: frame)
+        drawPhotoGuide(in: frame)
+    }
+
+    private func drawCorners(in frame: CGRect) {
+        let path = UIBezierPath()
+        let inset = Self.cornerBorder / 2
+        let left = frame.minX + inset
+        let top = frame.minY + inset
+        let right = frame.maxX - inset
+        let bottom = frame.maxY - inset
+        let size = Self.cornerSize
+
+        path.move(to: CGPoint(x: left, y: top + size))
+        path.addLine(to: CGPoint(x: left, y: top))
+        path.addLine(to: CGPoint(x: left + size, y: top))
+
+        path.move(to: CGPoint(x: right - size, y: top))
+        path.addLine(to: CGPoint(x: right, y: top))
+        path.addLine(to: CGPoint(x: right, y: top + size))
+
+        path.move(to: CGPoint(x: left, y: bottom - size))
+        path.addLine(to: CGPoint(x: left, y: bottom))
+        path.addLine(to: CGPoint(x: left + size, y: bottom))
+
+        path.move(to: CGPoint(x: right - size, y: bottom))
+        path.addLine(to: CGPoint(x: right, y: bottom))
+        path.addLine(to: CGPoint(x: right, y: bottom - size))
+
+        UIColor.white.setStroke()
+        path.lineWidth = Self.cornerBorder
+        path.stroke()
+    }
+
+    private func drawPhotoGuide(in frame: CGRect) {
+        let width = frame.width * Self.guideWidthFraction
+        let height = width * 4 / 3
+        let margin: CGFloat = 12
+        let guide = CGRect(
+            x: frame.maxX - margin - width,
+            y: frame.maxY - margin - height,
+            width: width,
+            height: height
+        )
+        let path = UIBezierPath(roundedRect: guide, cornerRadius: Self.guideRadius)
+        path.setLineDash([6, 4], count: 2, phase: 0)
+        path.lineWidth = 1
+        UIColor.white.withAlphaComponent(0.25).setStroke()
+        path.stroke()
+    }
+}

package/ios/OnePassSDK/Ocr/KtpImagePreparer.swift

@@ -0,0 +1,90 @@
+import UIKit
+
+enum KtpImagePreparer {
+    static let maxUploadDimension: CGFloat = 1600
+    static let jpegQuality: CGFloat = 0.9
+
+    struct Prepared {
+        let image: UIImage
+        let jpegData: Data
+    }
+
+    static func cropToFrame(image: UIImage, displaySize: CGSize, frame: CGRect) -> Prepared {
+        let upright = normalizedOrientation(image)
+        guard
+            let cgImage = upright.cgImage,
+            displaySize.width > 0,
+            displaySize.height > 0,
+            frame.width > 0
+        else {
+            return Prepared(
+                image: upright,
+                jpegData: upright.jpegData(compressionQuality: jpegQuality) ?? Data()
+            )
+        }
+        let region = CoverFitCrop.compute(
+            photoWidth: cgImage.width,
+            photoHeight: cgImage.height,
+            displayWidth: Int(displaySize.width),
+            displayHeight: Int(displaySize.height),
+            frame: frame
+        )
+        let cropRect = CGRect(
+            x: region.left,
+            y: region.top,
+            width: region.width,
+            height: region.height
+        )
+        guard let croppedCg = cgImage.cropping(to: cropRect) else {
+            return Prepared(
+                image: upright,
+                jpegData: upright.jpegData(compressionQuality: jpegQuality) ?? Data()
+            )
+        }
+        let cropped = downscale(UIImage(cgImage: croppedCg))
+        return Prepared(
+            image: cropped,
+            jpegData: cropped.jpegData(compressionQuality: jpegQuality) ?? Data()
+        )
+    }
+
+    static func cropToDetectedBounds(image: UIImage, bounds: CGRect?) -> UIImage {
+        guard let bounds, let cgImage = image.cgImage else { return image }
+        let region = KtpAutoCrop.cropTo(
+            bounds: bounds,
+            imageSize: CGSize(width: cgImage.width, height: cgImage.height),
+            targetRatio: KtpFrameOverlayView.frameRatio
+        )
+        let rect = CGRect(
+            x: region.left,
+            y: region.top,
+            width: region.width,
+            height: region.height
+        )
+        guard let cropped = cgImage.cropping(to: rect) else { return image }
+        return downscale(UIImage(cgImage: cropped))
+    }
+
+    static func downscale(_ image: UIImage) -> UIImage {
+        let longestSide = max(image.size.width, image.size.height)
+        guard longestSide > maxUploadDimension else { return image }
+        let scale = maxUploadDimension / longestSide
+        let target = CGSize(width: image.size.width * scale, height: image.size.height * scale)
+        let format = UIGraphicsImageRendererFormat.default()
+        format.scale = 1
+        format.opaque = true
+        return UIGraphicsImageRenderer(size: target, format: format).image { _ in
+            image.draw(in: CGRect(origin: .zero, size: target))
+        }
+    }
+
+    static func normalizedOrientation(_ image: UIImage) -> UIImage {
+        guard image.imageOrientation != .up else { return image }
+        let format = UIGraphicsImageRendererFormat.default()
+        format.scale = image.scale
+        format.opaque = true
+        return UIGraphicsImageRenderer(size: image.size, format: format).image { _ in
+            image.draw(in: CGRect(origin: .zero, size: image.size))
+        }
+    }
+}