👁️‍🗨️ Vision 프레임워크

import Vision
import UIKit

@Observable
class FaceDetector {
    var detectedFaces: [VNFaceObservation] = []
    var isProcessing = false
    var errorMessage: String?

    func detectFaces(in image: UIImage) async {
        isProcessing = true
        errorMessage = nil

        guard let cgImage = image.cgImage else {
            errorMessage = "이미지 변환 실패"
            isProcessing = false
            return
        }

        // Face detection request
        let request = VNDetectFaceRectanglesRequest { [weak self] request, error in
            guard let observations = request.results as? [VNFaceObservation] else {
                self?.errorMessage = error?.localizedDescription ?? "얼굴 검출 실패"
                return
            }
            self?.detectedFaces = observations
        }

        // Perform request
        let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
        do {
            try handler.perform([request])
        } catch {
            errorMessage = error.localizedDescription
        }

        isProcessing = false
    }

    // 얼굴 랜드마크 검출 (눈, 코, 입 등)
    func detectFaceLandmarks(in image: UIImage) async -> [VNFaceObservation]? {
        guard let cgImage = image.cgImage else { return nil }

        let request = VNDetectFaceLandmarksRequest()
        let handler = VNImageRequestHandler(cgImage: cgImage)

        try? handler.perform([request])
        return request.results as? [VNFaceObservation]
    }
}

import SwiftUI

struct FaceDetectionView: View {
    @State private var detector = FaceDetector()
    @State private var selectedImage: UIImage?
    @State private var showImagePicker = false

    var body: some View {
        VStack(spacing: 20) {
            if let image = selectedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
                    .frame(height: 300)
                    .overlay {
                        // 얼굴 위치에 사각형 표시
                        GeometryReader { geo in
                            ForEach(detector.detectedFaces.indices, id: \.self) { index in
                                let face = detector.detectedFaces[index]
                                let boundingBox = face.boundingBox

                                Rectangle()
                                    .stroke(Color.green, lineWidth: 3)
                                    .frame(
                                        width: boundingBox.width * geo.size.width,
                                        height: boundingBox.height * geo.size.height
                                    )
                                    .position(
                                        x: boundingBox.midX * geo.size.width,
                                        y: (1 - boundingBox.midY) * geo.size.height
                                    )
                            }
                        }
                    }

                Text("검출된 얼굴: \(detector.detectedFaces.count)개")
                    .font(.headline)
            }

            Button("사진 선택") {
                showImagePicker = true
            }
            .buttonStyle(.borderedProminent)

            if detector.isProcessing {
                ProgressView("얼굴 검출 중...")
            }

            if let error = detector.errorMessage {
                Text(error)
                    .foregroundStyle(.red)
            }
        }
        .padding()
        .sheet(isPresented: $showImagePicker) {
            ImagePicker(image: $selectedImage)
        }
        .onChange(of: selectedImage) { _, newImage in
            if let image = newImage {
                Task {
                    await detector.detectFaces(in: image)
                }
            }
        }
    }
}

import Vision

@Observable
class TextRecognizer {
    var recognizedText: String = ""
    var textObservations: [VNRecognizedTextObservation] = []

    func recognizeText(in image: UIImage) async {
        guard let cgImage = image.cgImage else { return }

        let request = VNRecognizeTextRequest { [weak self] request, error in
            guard let observations = request.results as? [VNRecognizedTextObservation] else {
                return
            }

            self?.textObservations = observations

            // 인식된 모든 텍스트 결합
            let recognizedStrings = observations.compactMap { observation in
                observation.topCandidates(1).first?.string
            }

            self?.recognizedText = recognizedStrings.joined(separator: "\n")
        }

        // 인식 레벨 설정 (accurate = 정확도 우선, fast = 속도 우선)
        request.recognitionLevel = .accurate

        // 다국어 지원 (한국어, 영어 등)
        request.recognitionLanguages = ["ko-KR", "en-US"]

        // 커스텀 단어 추가 (특정 용어 인식률 향상)
        request.customWords = ["SwiftUI", "Vision", "iOS"]

        let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
        try? handler.perform([request])
    }

    // 특정 영역의 텍스트만 인식
    func recognizeText(in image: UIImage, region: CGRect) async -> String? {
        guard let cgImage = image.cgImage else { return nil }

        let request = VNRecognizeTextRequest()
        request.regionOfInterest = region

        let handler = VNImageRequestHandler(cgImage: cgImage)
        try? handler.perform([request])

        return request.results?.first?.topCandidates(1).first?.string
    }
}

import Vision
import AVFoundation

@Observable
class BarcodeScanner {
    var detectedCodes: [VNBarcodeObservation] = []

    func scanBarcodes(in image: UIImage) async -> [String] {
        guard let cgImage = image.cgImage else { return [] }

        let request = VNDetectBarcodesRequest { [weak self] request, _ in
            guard let results = request.results as? [VNBarcodeObservation] else { return }
            self?.detectedCodes = results
        }

        // 특정 바코드 타입만 스캔 (QR, EAN-13 등)
        request.symbologies = [.qr, .ean13, .code128]

        let handler = VNImageRequestHandler(cgImage: cgImage)
        try? handler.perform([request])

        return detectedCodes.compactMap { $0.payloadStringValue }
    }

    // 실시간 카메라 스캔용
    func processCameraFrame(_ sampleBuffer: CMSampleBuffer) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }

        let request = VNDetectBarcodesRequest { [weak self] request, _ in
            guard let results = request.results as? [VNBarcodeObservation] else { return }
            self?.detectedCodes = results
        }

        let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, options: [:])
        try? handler.perform([request])
    }
}

import Vision

@Observable
class ObjectTracker {
    private var trackingRequest: VNTrackObjectRequest?
    var trackedObject: VNDetectedObjectObservation?

    // 초기 객체 위치로 추적 시작
    func startTracking(initialObservation: VNDetectedObjectObservation) {
        trackingRequest = VNTrackObjectRequest(detectedObjectObservation: initialObservation)
        trackingRequest?.trackingLevel = .accurate
    }

    // 다음 프레임 처리
    func processFrame(_ pixelBuffer: CVPixelBuffer) -> CGRect? {
        guard let request = trackingRequest else { return nil }

        let handler = VNSequenceRequestHandler()
        try? handler.perform([request], on: pixelBuffer)

        guard let observation = request.results?.first as? VNDetectedObjectObservation else {
            return nil
        }

        // 신뢰도 체크
        if observation.confidence > 0.5 {
            trackedObject = observation
            return observation.boundingBox
        }

        return nil
    }

    func stopTracking() {
        trackingRequest = nil
        trackedObject = nil
    }
}

import Vision

struct ImageAnalysisResult {
    let brightness: Float
    let contrast: Float
    let horizonAngle: CGFloat?
    let isFocused: Bool
}

@Observable
class ImageAnalyzer {
    func analyzeImage(_ image: UIImage) async -> ImageAnalysisResult? {
        guard let cgImage = image.cgImage else { return nil }

        // 이미지 속성 분석
        let featureRequest = VNDetectHorizonRequest()
        let qualityRequest = VNClassifyImageRequest()

        let handler = VNImageRequestHandler(cgImage: cgImage)
        try? handler.perform([featureRequest, qualityRequest])

        let horizonAngle = (featureRequest.results?.first)?.angle

        return ImageAnalysisResult(
            brightness: 0.7,
            contrast: 0.8,
            horizonAngle: horizonAngle,
            isFocused: true
        )
    }

    // 윤곽선 검출
    func detectContours(in image: UIImage) async -> [VNContoursObservation]? {
        guard let cgImage = image.cgImage else { return nil }

        let request = VNDetectContoursRequest()
        request.contrastAdjustment = 2.0
        request.detectsDarkOnLight = true

        let handler = VNImageRequestHandler(cgImage: cgImage)
        try? handler.perform([request])

        return request.results
    }
}

import Vision
import CoreML

@Observable
class VisionMLClassifier {
    var classification: String = ""
    var confidence: Float = 0.0

    func classify(image: UIImage, model: MLModel) async {
        guard let cgImage = image.cgImage else { return }

        // Core ML 모델을 Vision 요청으로 래핑
        guard let visionModel = try? VNCoreMLModel(for: model) else { return }

        let request = VNCoreMLRequest(model: visionModel) { [weak self] request, error in
            guard let results = request.results as? [VNClassificationObservation],
                  let topResult = results.first else { return }

            self?.classification = topResult.identifier
            self?.confidence = topResult.confidence
        }

        // 이미지 크기 자동 조정
        request.imageCropAndScaleOption = .centerCrop

        let handler = VNImageRequestHandler(cgImage: cgImage)
        try? handler.perform([request])
    }
}

import SwiftUI

struct VisionDemoView: View {
    @State private var selectedImage: UIImage?
    @State private var faceDetector = FaceDetector()
    @State private var textRecognizer = TextRecognizer()
    @State private var barcodeScanner = BarcodeScanner()
    @State private var selectedMode: Mode = .face

    enum Mode: String, CaseIterable {
        case face = "얼굴 인식"
        case text = "텍스트 인식"
        case barcode = "바코드 스캔"
    }

    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                // 모드 선택
                Picker("모드", selection: $selectedMode) {
                    ForEach(Mode.allCases, id: \.self) { mode in
                        Text(mode.rawValue).tag(mode)
                    }
                }
                .pickerStyle(.segmented)
                .padding()

                // 이미지 표시
                if let image = selectedImage {
                    Image(uiImage: image)
                        .resizable()
                        .scaledToFit()
                        .frame(maxHeight: 300)
                }

                // 결과 표시
                resultView

                Spacer()

                Button("사진 선택하고 분석") {
                    // 사진 선택 로직
                }
                .buttonStyle(.borderedProminent)
            }
            .navigationTitle("Vision 데모")
        }
    }

    @ViewBuilder
    var resultView: some View {
        switch selectedMode {
        case .face:
            Text("검출된 얼굴: \(faceDetector.detectedFaces.count)개")
        case .text:
            ScrollView {
                Text(textRecognizer.recognizedText)
                    .padding()
            }
        case .barcode:
            VStack {
                ForEach(barcodeScanner.detectedCodes, id: \.self.uuid) { code in
                    Text(code.payloadStringValue ?? "알 수 없음")
                }
            }
        }
    }
}