32e7c25ed7
feat(Quick): 优化RegionCameraView裁剪算法 重构RegionImageCropper裁剪逻辑，改用纯几何aspect-fill反算方法， 将屏上小框坐标直接映射到照片像素rect，避免使用 metadataOutputRectConverted导致的坐标轴对调问题。 主要变更: - 移除基于归一化rect的裁剪方式 - 新增cropRect函数进行几何反算 - 修复传感器横向坐标与竖屏照片方向不一致的问题 - 保持裁剪精度的同时提升算法稳定性 ```
373 lines
14 KiB
Swift
373 lines
14 KiB
Swift
import SwiftUI
|
|
import AVFoundation
|
|
import UIKit
|
|
import Combine
|
|
|
|
/// 异常项快拍 · 局部相机。
|
|
/// 实时预览 + 居中小框 + 快门 → **裁剪到小框区域**的 UIImage 回调。
|
|
/// 只在真机可用(模拟器无相机,QuickRegionCaptureFlow 退化到 PhotoPicker)。
|
|
///
|
|
/// 裁剪原理:先把拍到的照片 bake 成 `.up`(竖屏),再用纯几何 aspect-fill 反算把屏上小框
|
|
/// (view 点坐标)映射到照片像素 rect(见 `RegionImageCropper`)。
|
|
/// 不用 `metadataOutputRectConverted` —— 它返回传感器横向坐标,套到竖屏照片会轴对调裁出竖条。
|
|
struct RegionCameraView: View {
|
|
let onCapture: (UIImage) -> Void
|
|
let onCancel: () -> Void
|
|
|
|
@StateObject private var controller = RegionCameraController()
|
|
@State private var authState: AuthState = .checking
|
|
@State private var isCapturing = false
|
|
@State private var flash = false
|
|
|
|
enum AuthState { case checking, authorized, denied }
|
|
|
|
var body: some View {
|
|
ZStack {
|
|
Color.black.ignoresSafeArea()
|
|
|
|
switch authState {
|
|
case .checking:
|
|
ProgressView().tint(.white)
|
|
case .denied:
|
|
deniedView
|
|
case .authorized:
|
|
cameraStack
|
|
}
|
|
|
|
if flash {
|
|
Color.white.ignoresSafeArea().transition(.opacity)
|
|
}
|
|
}
|
|
.task { await resolveAuth() }
|
|
}
|
|
|
|
// MARK: - 相机 + 小框 + 控件
|
|
|
|
private var cameraStack: some View {
|
|
GeometryReader { proxy in
|
|
let box = RegionFraming.box(in: proxy.size)
|
|
ZStack {
|
|
RegionCameraPreview(controller: controller)
|
|
.ignoresSafeArea()
|
|
|
|
// 框外压暗(even-odd 挖空),只突出小框内
|
|
Canvas { ctx, size in
|
|
var path = Path(CGRect(origin: .zero, size: size))
|
|
path.addPath(Path(roundedRect: box, cornerRadius: Tj.Radius.md))
|
|
ctx.fill(path, with: .color(.black.opacity(0.5)), style: FillStyle(eoFill: true))
|
|
}
|
|
.ignoresSafeArea()
|
|
.allowsHitTesting(false)
|
|
|
|
// 小框边
|
|
RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
|
|
.strokeBorder(Color.white.opacity(0.95),
|
|
style: StrokeStyle(lineWidth: 2, dash: [8, 6]))
|
|
.frame(width: box.width, height: box.height)
|
|
.position(x: box.midX, y: box.midY)
|
|
.allowsHitTesting(false)
|
|
|
|
// 提示
|
|
Text("把异常项放进框里 · 对准一两行")
|
|
.font(.system(size: 13, weight: .medium))
|
|
.foregroundStyle(.white)
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 6)
|
|
.background(Capsule().fill(.black.opacity(0.4)))
|
|
.position(x: box.midX, y: box.minY - 22)
|
|
.allowsHitTesting(false)
|
|
|
|
controlsOverlay
|
|
}
|
|
}
|
|
}
|
|
|
|
private var controlsOverlay: some View {
|
|
VStack {
|
|
HStack {
|
|
Button {
|
|
onCancel()
|
|
} label: {
|
|
Text("取消")
|
|
.font(.system(size: 16, weight: .medium))
|
|
.foregroundStyle(.white)
|
|
.padding(.horizontal, 14)
|
|
.padding(.vertical, 8)
|
|
.background(Capsule().fill(.black.opacity(0.35)))
|
|
}
|
|
Spacer()
|
|
}
|
|
.padding(.horizontal, 18)
|
|
.padding(.top, 8)
|
|
|
|
Spacer()
|
|
|
|
shutterButton
|
|
.padding(.bottom, 36)
|
|
}
|
|
}
|
|
|
|
private var shutterButton: some View {
|
|
Button {
|
|
capture()
|
|
} label: {
|
|
ZStack {
|
|
Circle().fill(.white).frame(width: 72, height: 72)
|
|
Circle().strokeBorder(.white.opacity(0.6), lineWidth: 3).frame(width: 84, height: 84)
|
|
if isCapturing {
|
|
ProgressView().tint(.black)
|
|
}
|
|
}
|
|
}
|
|
.disabled(isCapturing)
|
|
.accessibilityLabel("拍摄异常项")
|
|
}
|
|
|
|
private var deniedView: some View {
|
|
VStack(spacing: 16) {
|
|
Image(systemName: "camera.fill")
|
|
.font(.system(size: 40))
|
|
.foregroundStyle(.white.opacity(0.8))
|
|
Text("相机权限未开启")
|
|
.font(.tjH2())
|
|
.foregroundStyle(.white)
|
|
Text("异常项快拍需要相机。去「设置 → 康康 → 相机」打开后再回来。")
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(.white.opacity(0.7))
|
|
.multilineTextAlignment(.center)
|
|
.padding(.horizontal, 36)
|
|
HStack(spacing: 12) {
|
|
Button("取消") { onCancel() }
|
|
.font(.system(size: 15))
|
|
.foregroundStyle(.white)
|
|
.padding(.horizontal, 18).padding(.vertical, 10)
|
|
.background(Capsule().strokeBorder(.white.opacity(0.5), lineWidth: 1))
|
|
Button("去设置") {
|
|
if let url = URL(string: UIApplication.openSettingsURLString) {
|
|
UIApplication.shared.open(url)
|
|
}
|
|
}
|
|
.font(.system(size: 15, weight: .semibold))
|
|
.foregroundStyle(.black)
|
|
.padding(.horizontal, 18).padding(.vertical, 10)
|
|
.background(Capsule().fill(.white))
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - 行为
|
|
|
|
private func capture() {
|
|
guard !isCapturing else { return }
|
|
isCapturing = true
|
|
withAnimation(.easeOut(duration: 0.08)) { flash = true }
|
|
controller.capture { image in
|
|
withAnimation(.easeIn(duration: 0.15)) { flash = false }
|
|
isCapturing = false
|
|
guard let image else { return }
|
|
onCapture(image)
|
|
}
|
|
}
|
|
|
|
private func resolveAuth() async {
|
|
switch AVCaptureDevice.authorizationStatus(for: .video) {
|
|
case .authorized:
|
|
authState = .authorized
|
|
case .notDetermined:
|
|
let granted = await AVCaptureDevice.requestAccess(for: .video)
|
|
authState = granted ? .authorized : .denied
|
|
default:
|
|
authState = .denied
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - 小框几何(UIView 与 SwiftUI 覆盖层共用,保证坐标一致)
|
|
|
|
enum RegionFraming {
|
|
/// 居中、略高于中心的小框。宽 84% 屏宽,高取 160 与 28% 屏高的较小值。
|
|
static func box(in size: CGSize) -> CGRect {
|
|
guard size.width > 0, size.height > 0 else { return .zero }
|
|
let w = size.width * 0.84
|
|
let h = min(160, size.height * 0.28)
|
|
let x = (size.width - w) / 2
|
|
let y = (size.height - h) / 2 - size.height * 0.06
|
|
return CGRect(x: x, y: y, width: w, height: h)
|
|
}
|
|
}
|
|
|
|
// MARK: - 裁剪纯函数
|
|
|
|
enum RegionImageCropper {
|
|
/// 把屏上小框(view 点坐标)按 `.resizeAspectFill` 反算到 `.up` 照片的像素裁剪 rect。
|
|
/// 前提:预览以 aspect-fill 铺满 viewSize,照片与预览同源、同为竖屏方向。
|
|
/// 纯几何、方向自洽 —— 不用 `metadataOutputRectConverted`(它返回传感器**横向**坐标,
|
|
/// 套到竖屏照片会 x/y 轴对调,把宽框裁成竖窄条,见 RegionImageCropperTests)。越界自动夹紧。
|
|
static func cropRect(photoPixelSize p: CGSize, box: CGRect, in viewSize: CGSize) -> CGRect {
|
|
guard p.width > 0, p.height > 0, viewSize.width > 0, viewSize.height > 0 else { return .zero }
|
|
// aspect-fill:取较大缩放系数让照片铺满视图,溢出部分被裁。
|
|
let scale = max(viewSize.width / p.width, viewSize.height / p.height)
|
|
let scaledW = p.width * scale
|
|
let scaledH = p.height * scale
|
|
// 缩放后照片相对视图居中,溢出维度的原点为负。
|
|
let ox = (viewSize.width - scaledW) / 2
|
|
let oy = (viewSize.height - scaledH) / 2
|
|
// 视图点 → 照片像素:先减去居中偏移,再除以缩放系数。
|
|
var x = (box.minX - ox) / scale
|
|
var y = (box.minY - oy) / scale
|
|
var w = box.width / scale
|
|
var h = box.height / scale
|
|
// 夹紧到照片范围内。
|
|
x = max(0, min(p.width, x))
|
|
y = max(0, min(p.height, y))
|
|
w = max(0, min(p.width - x, w))
|
|
h = max(0, min(p.height - y, h))
|
|
return CGRect(x: x, y: y, width: w, height: h).integral
|
|
}
|
|
|
|
/// 按屏上小框裁 `.up` 照片(`box` / `viewSize` 同为 view 点坐标);失败回退原图。
|
|
static func crop(_ image: UIImage, box: CGRect, viewSize: CGSize) -> UIImage {
|
|
guard let cg = image.cgImage else { return image }
|
|
let rect = cropRect(photoPixelSize: CGSize(width: cg.width, height: cg.height),
|
|
box: box, in: viewSize)
|
|
guard rect.width >= 1, rect.height >= 1, let cropped = cg.cropping(to: rect) else { return image }
|
|
return UIImage(cgImage: cropped, scale: image.scale, orientation: .up)
|
|
}
|
|
}
|
|
|
|
extension UIImage {
|
|
/// 把 EXIF 方向 bake 进像素,返回 `.up` 方向图,便于按归一化 rect 直接裁 CGImage。
|
|
func normalizedUp() -> UIImage {
|
|
if imageOrientation == .up { return self }
|
|
let format = UIGraphicsImageRendererFormat.default()
|
|
format.scale = scale
|
|
let renderer = UIGraphicsImageRenderer(size: size, format: format)
|
|
return renderer.image { _ in draw(in: CGRect(origin: .zero, size: size)) }
|
|
}
|
|
}
|
|
|
|
// MARK: - AVFoundation 桥接
|
|
|
|
/// SwiftUI 持有,作为快门触发的句柄(weak 指向真正的 UIView)。
|
|
final class RegionCameraController: ObservableObject {
|
|
weak var view: RegionPreviewUIView?
|
|
func capture(_ completion: @escaping (UIImage?) -> Void) {
|
|
guard let view else { completion(nil); return }
|
|
view.capture(completion: completion)
|
|
}
|
|
}
|
|
|
|
struct RegionCameraPreview: UIViewRepresentable {
|
|
let controller: RegionCameraController
|
|
|
|
func makeUIView(context: Context) -> RegionPreviewUIView {
|
|
let v = RegionPreviewUIView()
|
|
controller.view = v
|
|
return v
|
|
}
|
|
|
|
func updateUIView(_ uiView: RegionPreviewUIView, context: Context) {}
|
|
|
|
static func dismantleUIView(_ uiView: RegionPreviewUIView, coordinator: ()) {
|
|
uiView.stop()
|
|
}
|
|
}
|
|
|
|
/// 实时预览 + 单张拍摄,拍完按小框裁剪。
|
|
final class RegionPreviewUIView: UIView, AVCapturePhotoCaptureDelegate {
|
|
private let session = AVCaptureSession()
|
|
private let output = AVCapturePhotoOutput()
|
|
private var previewLayer: AVCaptureVideoPreviewLayer?
|
|
private var setupDone = false
|
|
private var captureCompletion: ((UIImage?) -> Void)?
|
|
|
|
override func didMoveToWindow() {
|
|
super.didMoveToWindow()
|
|
guard !setupDone, window != nil else { return }
|
|
setupDone = true
|
|
configure()
|
|
}
|
|
|
|
private func configure() {
|
|
session.beginConfiguration()
|
|
session.sessionPreset = .photo
|
|
guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
|
|
let input = try? AVCaptureDeviceInput(device: device),
|
|
session.canAddInput(input) else {
|
|
session.commitConfiguration()
|
|
return
|
|
}
|
|
session.addInput(input)
|
|
if session.canAddOutput(output) { session.addOutput(output) }
|
|
session.commitConfiguration()
|
|
|
|
let preview = AVCaptureVideoPreviewLayer(session: session)
|
|
preview.videoGravity = .resizeAspectFill
|
|
preview.frame = bounds
|
|
layer.addSublayer(preview)
|
|
self.previewLayer = preview
|
|
applyPortrait(preview.connection)
|
|
|
|
DispatchQueue.global(qos: .userInitiated).async { [weak self] in
|
|
self?.session.startRunning()
|
|
}
|
|
}
|
|
|
|
/// 锁竖屏(iOS 17+ 用 videoRotationAngle,避免 videoOrientation 弃用告警)。
|
|
private func applyPortrait(_ connection: AVCaptureConnection?) {
|
|
guard let connection else { return }
|
|
if connection.isVideoRotationAngleSupported(90) {
|
|
connection.videoRotationAngle = 90
|
|
}
|
|
}
|
|
|
|
override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
previewLayer?.frame = bounds
|
|
}
|
|
|
|
func capture(completion: @escaping (UIImage?) -> Void) {
|
|
guard session.isRunning else { completion(nil); return }
|
|
captureCompletion = completion
|
|
applyPortrait(output.connection(with: .video))
|
|
output.capturePhoto(with: AVCapturePhotoSettings(), delegate: self)
|
|
}
|
|
|
|
func stop() {
|
|
guard session.isRunning else { return }
|
|
DispatchQueue.global(qos: .userInitiated).async { [weak self] in
|
|
self?.session.stopRunning()
|
|
}
|
|
}
|
|
|
|
func photoOutput(_ output: AVCapturePhotoOutput,
|
|
didFinishProcessingPhoto photo: AVCapturePhoto,
|
|
error: Error?) {
|
|
let completion = captureCompletion
|
|
captureCompletion = nil
|
|
// 代理回调在 AVFoundation 私有队列,SwiftUI 状态更新必须切回主线程。
|
|
let deliver: (UIImage?) -> Void = { result in
|
|
DispatchQueue.main.async { completion?(result) }
|
|
}
|
|
guard error == nil,
|
|
let data = photo.fileDataRepresentation(),
|
|
let image = UIImage(data: data) else {
|
|
deliver(nil)
|
|
return
|
|
}
|
|
let upright = image.normalizedUp()
|
|
guard previewLayer != nil else {
|
|
deliver(upright)
|
|
return
|
|
}
|
|
// 裁剪走纯几何映射:预览以 .resizeAspectFill 铺满 bounds,照片与预览同源同为竖屏,
|
|
// 故屏上小框可按 aspect-fill 反算到照片像素 rect。读 bounds 几何回主线程更稳。
|
|
DispatchQueue.main.async {
|
|
let viewSize = self.bounds.size
|
|
let box = RegionFraming.box(in: viewSize)
|
|
let cropped = RegionImageCropper.crop(upright, box: box, viewSize: viewSize)
|
|
completion?(cropped)
|
|
}
|
|
}
|
|
}
|