1114 lines
53 KiB
Swift
1114 lines
53 KiB
Swift
import CoreML
|
|
import Vision
|
|
import UIKit
|
|
import StoreKit
|
|
import PDFKit
|
|
import FirebaseFirestore
|
|
import FirebaseStorage
|
|
import FirebaseAuth
|
|
import Network
|
|
import ImageIO
|
|
import CoreImage
|
|
|
|
struct SharedEngineResources {
|
|
static let context = CIContext()
|
|
}
|
|
|
|
// MARK: - MODEL MANAGER (OTA Updates)
|
|
class ModelManager {
|
|
static let shared = ModelManager()
|
|
private let defaults = UserDefaults.standard
|
|
|
|
func getModel(name: String) -> VNCoreMLModel? {
|
|
// 1. Check Documents (Downloaded Update)
|
|
if let docDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
|
|
let modelURL = docDir.appendingPathComponent("models/\(name).mlmodelc")
|
|
if FileManager.default.fileExists(atPath: modelURL.path),
|
|
let model = try? MLModel(contentsOf: modelURL),
|
|
let vnModel = try? VNCoreMLModel(for: model) {
|
|
return vnModel
|
|
}
|
|
}
|
|
|
|
// 2. Check Bundle (Built-in Fallback)
|
|
if let bundleURL = Bundle.main.url(forResource: name, withExtension: "mlmodelc"),
|
|
let model = try? MLModel(contentsOf: bundleURL),
|
|
let vnModel = try? VNCoreMLModel(for: model) {
|
|
return vnModel
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkForUpdates() {
|
|
guard FirebaseApp.app() != nil else { return }
|
|
let models = ["IYmtgFoilClassifier", "IYmtgConditionClassifier", "IYmtgStampClassifier", "IYmtgSetClassifier"]
|
|
|
|
for name in models {
|
|
let ref = Storage.storage().reference().child("models/\(name).mlmodel")
|
|
ref.getMetadata { meta, error in
|
|
guard let meta = meta, let remoteDate = meta.updated else { return }
|
|
let localDate = self.defaults.object(forKey: "ModelDate_\(name)") as? Date ?? Date.distantPast
|
|
|
|
if remoteDate > localDate {
|
|
let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent("\(name).mlmodel")
|
|
ref.write(toFile: tempURL) { url, error in
|
|
guard let url = url else { return }
|
|
DispatchQueue.global(qos: .utility).async {
|
|
do {
|
|
let compiledURL = try MLModel.compileModel(at: url)
|
|
let docDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("models")
|
|
try FileManager.default.createDirectory(at: docDir, withIntermediateDirectories: true)
|
|
let destURL = docDir.appendingPathComponent("\(name).mlmodelc")
|
|
let tempDestURL = docDir.appendingPathComponent("temp_\(name).mlmodelc")
|
|
|
|
try? FileManager.default.removeItem(at: tempDestURL)
|
|
try FileManager.default.copyItem(at: compiledURL, to: tempDestURL)
|
|
|
|
if FileManager.default.fileExists(atPath: destURL.path) {
|
|
_ = try FileManager.default.replaceItem(at: destURL, withItemAt: tempDestURL, backupItemName: nil, options: [])
|
|
} else {
|
|
try FileManager.default.moveItem(at: tempDestURL, to: destURL)
|
|
}
|
|
self.defaults.set(remoteDate, forKey: "ModelDate_\(name)")
|
|
print("✅ OTA Model Updated: \(name)")
|
|
} catch {
|
|
print("❌ Model Update Failed for \(name): \(error)")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - 0. ANALYSIS ACTOR
|
|
actor AnalysisActor {
|
|
private var database: [CardMetadata] = []
|
|
private var fingerprintCache: [UUID: VNFeaturePrintObservation] = [:]
|
|
|
|
func loadDatabase(from url: URL) throws {
|
|
let data = try Data(contentsOf: url, options: .mappedIfSafe)
|
|
let loaded = try JSONDecoder().decode([CardFingerprint].self, from: data)
|
|
self.fingerprintCache.removeAll()
|
|
self.database.removeAll()
|
|
|
|
for card in loaded {
|
|
if let obs = try? NSKeyedUnarchiver.unarchivedObject(ofClass: VNFeaturePrintObservation.self, from: card.featureData) {
|
|
self.fingerprintCache[card.id] = obs
|
|
}
|
|
self.database.append(CardMetadata(id: card.id, name: card.name, setCode: card.setCode, collectorNumber: card.collectorNumber, hasFoilPrinting: card.hasFoilPrinting, hasSerializedPrinting: card.hasSerializedPrinting ?? false, priceScanned: card.priceScanned))
|
|
}
|
|
}
|
|
|
|
func analyze(croppedImage: CGImage, orientation: CGImagePropertyOrientation) async -> (CardMetadata?, Bool) {
|
|
guard let print = try? await FeatureMatcher.generateFingerprint(from: croppedImage, orientation: orientation) else { return (nil, false) }
|
|
let result = FeatureMatcher.identify(scan: print, database: self.database, cache: self.fingerprintCache)
|
|
|
|
var resolvedCard: CardMetadata?
|
|
var detectedSerialized = false
|
|
|
|
switch result {
|
|
case .exact(let card):
|
|
resolvedCard = card
|
|
case .unknown:
|
|
return (nil, false)
|
|
case .ambiguous(_, let candidates):
|
|
// FIX: Pass orientation to OCR, otherwise it fails on portrait images (sideways text)
|
|
let (ocrSet, ocrNum, ocrYear, isSerialized) = OCREngine.readCardDetails(image: croppedImage, orientation: orientation)
|
|
detectedSerialized = isSerialized
|
|
|
|
// Run Heuristics to resolve specific ambiguities
|
|
let isAlpha = CornerDetector.isAlphaCorner(image: croppedImage, orientation: orientation)
|
|
let saturation = SaturationDetector.analyze(image: croppedImage, orientation: orientation)
|
|
let borderColor = BorderDetector.detect(image: croppedImage, orientation: orientation)
|
|
let hasListSymbol = ListSymbolDetector.hasListSymbol(image: croppedImage, orientation: orientation)
|
|
let hasStamp = StampDetector.hasStamp(image: croppedImage, orientation: orientation)
|
|
|
|
var filtered = candidates
|
|
|
|
// 1. Alpha (LEA) vs Beta (LEB)
|
|
if candidates.contains(where: { $0.setCode == "LEA" }) && candidates.contains(where: { $0.setCode == "LEB" }) {
|
|
if isAlpha { filtered = filtered.filter { $0.setCode == "LEA" } }
|
|
else { filtered = filtered.filter { $0.setCode == "LEB" } }
|
|
}
|
|
|
|
// 2. Unlimited (2ED) vs Revised (3ED)
|
|
if candidates.contains(where: { $0.setCode == "2ED" }) && candidates.contains(where: { $0.setCode == "3ED" }) {
|
|
if saturation > 0.25 { filtered = filtered.filter { $0.setCode == "2ED" } }
|
|
else { filtered = filtered.filter { $0.setCode == "3ED" || $0.setCode == "SUM" } }
|
|
}
|
|
|
|
// 3. The List / Mystery
|
|
if hasListSymbol {
|
|
let listSets = ["PLIST", "MB1", "UPLIST", "H1R"]
|
|
let listCandidates = filtered.filter { listSets.contains($0.setCode) }
|
|
if !listCandidates.isEmpty { filtered = listCandidates }
|
|
}
|
|
|
|
// 4. World Champ (Gold Border)
|
|
if borderColor == .gold {
|
|
let wcCandidates = filtered.filter { $0.setCode.hasPrefix("WC") }
|
|
if !wcCandidates.isEmpty { filtered = wcCandidates }
|
|
}
|
|
|
|
// 5. Promo Stamps
|
|
if hasStamp {
|
|
let promoCandidates = filtered.filter { $0.setCode.lowercased().hasPrefix("p") }
|
|
if !promoCandidates.isEmpty { filtered = promoCandidates }
|
|
}
|
|
|
|
// 6. Chronicles (White Border) vs Originals (Black Border)
|
|
let chroniclesOriginals = ["ARN", "ATQ", "LEG", "DRK"]
|
|
if candidates.contains(where: { $0.setCode == "CHR" }) && candidates.contains(where: { chroniclesOriginals.contains($0.setCode) }) {
|
|
if borderColor == .white { filtered = filtered.filter { $0.setCode == "CHR" } }
|
|
else if borderColor == .black { filtered = filtered.filter { chroniclesOriginals.contains($0.setCode) } }
|
|
}
|
|
|
|
// 7. Summer Magic (Edgar) - 1994 Copyright on Revised
|
|
if let year = ocrYear, year == "1994", candidates.contains(where: { $0.setCode == "3ED" }) {
|
|
let sumCandidates = filtered.filter { $0.setCode == "SUM" }
|
|
if !sumCandidates.isEmpty { filtered = sumCandidates }
|
|
} else if candidates.contains(where: { $0.setCode == "3ED" }) {
|
|
// If not explicitly 1994, assume Revised (3ED) and filter out Summer Magic (SUM)
|
|
filtered = filtered.filter { $0.setCode != "SUM" }
|
|
}
|
|
|
|
var resolved: CardMetadata?
|
|
if let set = ocrSet, let num = ocrNum, let match = filtered.first(where: { $0.setCode.uppercased() == set && $0.collectorNumber == num }) { resolved = match }
|
|
else if let set = ocrSet, let match = filtered.first(where: { $0.setCode.uppercased() == set }) { resolved = match }
|
|
else if let set = SetSymbolEngine.recognizeSet(image: croppedImage, orientation: orientation), let match = filtered.first(where: { $0.setCode.caseInsensitiveCompare(set) == .orderedSame }) { resolved = match }
|
|
else if let set = ClusterEngine.refine(candidates: filtered), let match = filtered.first(where: { $0.setCode == set }) { resolved = match }
|
|
else { resolved = filtered.first ?? candidates.first }
|
|
|
|
resolvedCard = resolved
|
|
}
|
|
|
|
guard let card = resolvedCard else { return (nil, false) }
|
|
|
|
// DB CHECK: Only run/trust OCR serialization if the card is known to have a serialized printing
|
|
if card.hasSerializedPrinting {
|
|
// If we had an exact match, OCR wasn't run yet. Run it now specifically for serialization.
|
|
if case .exact = result {
|
|
let (_, _, _, isSer) = OCREngine.readCardDetails(image: croppedImage, orientation: orientation)
|
|
detectedSerialized = isSer
|
|
}
|
|
} else {
|
|
detectedSerialized = false
|
|
}
|
|
|
|
return (card, detectedSerialized)
|
|
}
|
|
}
|
|
|
|
// MARK: - 1. STORE ENGINE
|
|
@MainActor
|
|
class StoreEngine: ObservableObject {
|
|
@Published var products: [Product] = []
|
|
@Published var showThankYou = false
|
|
var transactionListener: Task<Void, Never>? = nil
|
|
|
|
init() {
|
|
// FIX: Added [weak self] to prevent retain cycle
|
|
transactionListener = Task.detached { [weak self] in
|
|
for await result in Transaction.updates {
|
|
do {
|
|
guard let self = self else { return }
|
|
let transaction = try self.checkVerified(result)
|
|
await transaction.finish()
|
|
await MainActor.run { self.showThankYou = true }
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
|
|
deinit { transactionListener?.cancel() }
|
|
|
|
func loadProducts() async {
|
|
do {
|
|
let p = try await Product.products(for: AppConfig.tipJarProductIDs)
|
|
self.products = p
|
|
#if DEBUG
|
|
if p.isEmpty { print("⚠️ StoreEngine: No products found. Verify IAP ID in AppConfig.") }
|
|
#endif
|
|
} catch { print("Store Error: \(error)") }
|
|
}
|
|
|
|
func purchase(_ product: Product) async {
|
|
guard let result = try? await product.purchase() else { return }
|
|
switch result {
|
|
case .success(let verification):
|
|
if let transaction = try? checkVerified(verification) {
|
|
await transaction.finish()
|
|
self.showThankYou = true
|
|
}
|
|
case .pending, .userCancelled: break
|
|
@unknown default: break
|
|
}
|
|
}
|
|
|
|
nonisolated func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
|
|
switch result {
|
|
case .unverified: throw StoreError.failedVerification
|
|
case .verified(let safe): return safe
|
|
}
|
|
}
|
|
enum StoreError: Error { case failedVerification }
|
|
}
|
|
|
|
// MARK: - 2. PRICING ENGINE
|
|
actor ScryfallThrottler {
|
|
static let shared = ScryfallThrottler()
|
|
private var nextAllowedTime = Date.distantPast
|
|
|
|
func wait() async {
|
|
let now = Date()
|
|
let targetTime = max(now, nextAllowedTime)
|
|
nextAllowedTime = targetTime.addingTimeInterval(0.1)
|
|
|
|
let waitTime = targetTime.timeIntervalSince(now)
|
|
if waitTime > 0 {
|
|
try? await Task.sleep(nanoseconds: UInt64(waitTime * 1_000_000_000))
|
|
}
|
|
}
|
|
}
|
|
|
|
class InsuranceEngine {
|
|
struct PricingIdentifier: Codable { let set: String; let collector_number: String }
|
|
struct ScryfallData {
|
|
let price: Double?
|
|
let typeLine: String
|
|
let rarity: String?
|
|
let colors: [String]?
|
|
let isSerialized: Bool
|
|
}
|
|
|
|
static func getPriceKey(foilType: String, currency: CurrencyCode) -> String {
|
|
if foilType.caseInsensitiveCompare("Etched") == .orderedSame { return "\(currency.scryfallKey)_etched" }
|
|
let isFoil = foilType != "None" && foilType != AppConfig.Defaults.defaultFoil
|
|
let base = currency.scryfallKey
|
|
return isFoil ? "\(base)_foil" : base
|
|
}
|
|
|
|
static func updateTrends(cards: [SavedCard], currency: CurrencyCode, force: Bool = false, updateTimestamp: Bool = true) async -> ([UUID: Double], [UUID: (String?, [String]?, Bool)]) {
|
|
if !NetworkMonitor.shared.isConnected { return ([:], [:]) }
|
|
let lastUpdate = UserDefaults.standard.object(forKey: "LastPriceUpdate") as? Date ?? Date.distantPast
|
|
let isCacheExpired = Date().timeIntervalSince(lastUpdate) >= 86400
|
|
|
|
// Optimization: If cache is fresh, only fetch cards that are missing a price (Smart Partial Refresh)
|
|
let cardsToFetch = (force || isCacheExpired) ? cards : cards.filter { $0.currentValuation == nil }
|
|
if cardsToFetch.isEmpty { return ([:], [:]) }
|
|
|
|
var updates: [UUID: Double] = [:]
|
|
var metadataUpdates: [UUID: (String?, [String]?, Bool)] = [:]
|
|
let marketCards = cardsToFetch.filter { !$0.isCustomValuation }
|
|
let chunks = stride(from: 0, to: marketCards.count, by: 75).map { Array(marketCards[$0..<min($0 + 75, marketCards.count)]) }
|
|
|
|
for chunk in chunks {
|
|
await ScryfallThrottler.shared.wait()
|
|
let identifiers = chunk.map { PricingIdentifier(set: $0.setCode, collector_number: $0.collectorNumber) }
|
|
guard let body = try? JSONEncoder().encode(["identifiers": identifiers]) else { continue }
|
|
|
|
var request = URLRequest(url: URL(string: "https://api.scryfall.com/cards/collection")!)
|
|
request.httpMethod = "POST"
|
|
request.httpBody = body
|
|
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
|
|
request.addValue(AppConfig.scryfallUserAgent, forHTTPHeaderField: "User-Agent")
|
|
request.addValue("application/json", forHTTPHeaderField: "Accept")
|
|
|
|
if let (data, response) = try? await URLSession.shared.data(for: request),
|
|
(response as? HTTPURLResponse)?.statusCode == 200,
|
|
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
|
|
let dataArray = json["data"] as? [[String: Any]] {
|
|
|
|
for cardData in dataArray {
|
|
if let set = cardData["set"] as? String, let num = cardData["collector_number"] as? String,
|
|
let prices = cardData["prices"] as? [String: Any] {
|
|
|
|
// FIX: Case-insensitive set code matching (Scryfall returns lowercase, App uses Uppercase)
|
|
let matchingCards = chunk.filter { $0.setCode.caseInsensitiveCompare(set) == .orderedSame && $0.collectorNumber == num }
|
|
for card in matchingCards {
|
|
let priceKey = getPriceKey(foilType: card.foilType, currency: currency)
|
|
|
|
// Capture Metadata (Backfill)
|
|
let rarity = cardData["rarity"] as? String
|
|
let colors = cardData["color_identity"] as? [String]
|
|
let promoTypes = cardData["promo_types"] as? [String]
|
|
let isSer = promoTypes?.contains("serialized") ?? false
|
|
metadataUpdates[card.id] = (rarity, colors, isSer)
|
|
|
|
if let newPriceStr = prices[priceKey] as? String,
|
|
let newPrice = Double(newPriceStr),
|
|
!newPrice.isNaN, !newPrice.isInfinite {
|
|
updates[card.id] = newPrice
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (force || isCacheExpired) && updateTimestamp { UserDefaults.standard.set(Date(), forKey: "LastPriceUpdate") }
|
|
return (updates, metadataUpdates)
|
|
}
|
|
|
|
static func fetchPrice(setCode: String, number: String, foilType: String, currency: CurrencyCode) async -> ScryfallData {
|
|
if !NetworkMonitor.shared.isConnected { return ScryfallData(price: nil, typeLine: "Offline", rarity: nil, colors: nil, isSerialized: false) }
|
|
await ScryfallThrottler.shared.wait()
|
|
|
|
let encodedSet = setCode.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? setCode
|
|
let encodedNum = number.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? number
|
|
|
|
guard let url = URL(string: "https://api.scryfall.com/cards/\(encodedSet)/\(encodedNum)") else { return ScryfallData(price: nil, typeLine: "Error", rarity: nil, colors: nil, isSerialized: false) }
|
|
var request = URLRequest(url: url)
|
|
request.addValue(AppConfig.scryfallUserAgent, forHTTPHeaderField: "User-Agent")
|
|
|
|
guard let (data, _) = try? await URLSession.shared.data(for: request),
|
|
let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return ScryfallData(price: nil, typeLine: "Unknown", rarity: nil, colors: nil, isSerialized: false) }
|
|
|
|
let prices = json["prices"] as? [String: Any]
|
|
let priceKey = getPriceKey(foilType: foilType, currency: currency)
|
|
let price = Double(prices?[priceKey] as? String ?? "")
|
|
let rarity = json["rarity"] as? String
|
|
let colors = json["color_identity"] as? [String]
|
|
let promoTypes = json["promo_types"] as? [String]
|
|
let isSer = promoTypes?.contains("serialized") ?? false
|
|
return ScryfallData(price: price, typeLine: (json["type_line"] as? String) ?? "", rarity: rarity, colors: colors, isSerialized: isSer)
|
|
}
|
|
}
|
|
|
|
// MARK: - 3. SECURE DEV MODE
|
|
class DevEngine {
|
|
static var isDevMode = false
|
|
static func activateIfCompiled() {
|
|
#if ENABLE_DEV_MODE
|
|
isDevMode = true
|
|
print("⚠️ DEV MODE COMPILED")
|
|
#endif
|
|
}
|
|
static func saveRaw(image: UIImage, label: String) {
|
|
#if ENABLE_DEV_MODE
|
|
if isDevMode, let data = image.jpegData(compressionQuality: 1.0) {
|
|
let path = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("RawTrainingData")
|
|
try? FileManager.default.createDirectory(at: path, withIntermediateDirectories: true)
|
|
try? data.write(to: path.appendingPathComponent("TRAIN_\(label)_\(UUID().uuidString).jpg"))
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// MARK: - 4. CONDITION & ML
|
|
struct DamageObservation: Identifiable, Sendable {
|
|
let id = UUID()
|
|
let type: String
|
|
let rect: CGRect
|
|
let confidence: Float
|
|
}
|
|
|
|
class ConditionEngine {
|
|
enum Severity: Int { case minor=1; case critical=10 }
|
|
|
|
static var model: VNCoreMLModel? = {
|
|
guard AppConfig.enableConditionGrading else { return nil }
|
|
return ModelManager.shared.getModel(name: "IYmtgConditionClassifier")
|
|
}()
|
|
|
|
static func getSeverity(for type: String) -> Severity {
|
|
return (type == "Inking" || type == "Rips" || type == "WaterDamage") ? .critical : .minor
|
|
}
|
|
|
|
static func detectDamage(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> [DamageObservation] {
|
|
guard let model = model else { return [] }
|
|
let request = VNCoreMLRequest(model: model)
|
|
request.imageCropAndScaleOption = .scaleFill
|
|
let handler = VNImageRequestHandler(cgImage: image, orientation: orientation, options: [:])
|
|
do {
|
|
try handler.perform([request])
|
|
guard let results = request.results as? [VNRecognizedObjectObservation] else { return [] }
|
|
return results.filter { $0.confidence > 0.7 }.map { obs in
|
|
DamageObservation(type: obs.labels.first?.identifier ?? "Unknown", rect: obs.boundingBox, confidence: obs.confidence)
|
|
}
|
|
} catch { return [] }
|
|
}
|
|
|
|
static func overallGrade(damages: [DamageObservation]) -> String {
|
|
if model == nil && damages.isEmpty { return "Ungraded" }
|
|
var score = 0
|
|
for d in damages {
|
|
if getSeverity(for: d.type) == .critical { return "Damaged" }
|
|
score += 1
|
|
}
|
|
if score == 0 { return "Near Mint (NM)" }
|
|
if score <= 2 { return "Excellent (EX)" }
|
|
return "Played (PL)"
|
|
}
|
|
}
|
|
|
|
class OCREngine {
|
|
static func readCardDetails(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> (setCode: String?, number: String?, year: String?, isSerialized: Bool) {
|
|
let request = VNRecognizeTextRequest()
|
|
request.recognitionLevel = .accurate
|
|
request.usesLanguageCorrection = false
|
|
let handler = VNImageRequestHandler(cgImage: image, orientation: orientation)
|
|
try? handler.perform([request])
|
|
guard let obs = request.results as? [VNRecognizedTextObservation] else { return (nil, nil, nil, false) }
|
|
|
|
var possibleSetCode: String?
|
|
var possibleNumber: String?
|
|
var possibleYear: String?
|
|
var isSerialized = false
|
|
|
|
for observation in obs {
|
|
guard let candidate = observation.topCandidates(1).first else { continue }
|
|
let text = candidate.string.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
|
|
// Set Code: 3-5 chars, uppercase
|
|
// FIX: Ensure it's in the bottom half to avoid reading Card Name (e.g. "FOG") as Set Code
|
|
// FIX: Must contain at least one letter to avoid reading years or numbers as Set Codes
|
|
if text.count >= 3 && text.count <= 5 && text == text.uppercased() && possibleSetCode == nil && text.rangeOfCharacter(from: .letters) != nil {
|
|
// Vision coordinates: (0,0) is Bottom-Left. y < 0.5 is Bottom Half.
|
|
// FIX: Tighten to y < 0.2 to match Collector Number and fully exclude Text Box (e.g. "FLY")
|
|
if observation.boundingBox.origin.y < 0.2 { possibleSetCode = text }
|
|
}
|
|
|
|
// Collector Number & Serialized
|
|
if text.contains("/") && text.count <= 10 {
|
|
// Detect "XXX/500" pattern
|
|
// FILTER: Ignore Power/Toughness in bottom-right corner (x > 0.75, y < 0.2)
|
|
// VNObservation bbox is normalized (0,0 is bottom-left)
|
|
if observation.boundingBox.origin.x > 0.75 && observation.boundingBox.origin.y < 0.2 { continue }
|
|
|
|
// FILTER: Treat anything below the type line (y < 0.5) as standard info (Set/Collector Number)
|
|
// This prevents false positives from text box numbers or standard collector info being flagged as serialized.
|
|
// FIX: Tighten standard location to bottom 20% to avoid text box stats (e.g. "10/10" token)
|
|
let isStandardLocation = observation.boundingBox.origin.y < 0.2
|
|
|
|
let parts = text.split(separator: "/")
|
|
if parts.count == 2 {
|
|
let numStr = parts[0].trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let denomStr = parts[1].trimmingCharacters(in: .whitespacesAndNewlines)
|
|
if let num = Int(numStr), let denom = Int(denomStr) {
|
|
if isStandardLocation {
|
|
// Ignore small denominators (e.g. 1/1, 2/2) in text box to avoid P/T false positives
|
|
if denom < 10 { continue }
|
|
if possibleNumber == nil { possibleNumber = numStr }
|
|
} else if observation.boundingBox.origin.y > 0.5 {
|
|
// FIX: Only consider Top Half (Art) as Serialized to avoid Text Box false positives
|
|
isSerialized = true
|
|
}
|
|
}
|
|
}
|
|
} else if text.count >= 1 && text.count <= 5, let first = text.first, first.isNumber, possibleNumber == nil {
|
|
// FIX: Only accept simple numbers if they are at the very bottom (Collector Number location)
|
|
// AND not in the bottom-right corner (Power/Toughness zone)
|
|
// This prevents reading mana costs, power/toughness, or damage values as collector numbers
|
|
if observation.boundingBox.origin.y < 0.2 && observation.boundingBox.origin.x < 0.75 { possibleNumber = text }
|
|
}
|
|
|
|
// Copyright Year (for Summer Magic detection)
|
|
// Look for 1993-2025
|
|
if let range = text.range(of: #"(19|20)\d{2}"#, options: .regularExpression) {
|
|
if observation.boundingBox.origin.y < 0.15 {
|
|
possibleYear = String(text[range])
|
|
}
|
|
}
|
|
}
|
|
return (possibleSetCode, possibleNumber, possibleYear, isSerialized)
|
|
}
|
|
}
|
|
|
|
class TrainingUploader {
|
|
static func upload(image: UIImage, label: String, force: Bool = false) {
|
|
if !force && !AppConfig.isTrainingOptIn { return }
|
|
guard FirebaseApp.app() != nil else { return }
|
|
let safeLabel = label.replacingOccurrences(of: "/", with: "-")
|
|
let ref = Storage.storage().reference().child("training/\(safeLabel)/\(UUID().uuidString).jpg")
|
|
if let data = image.jpegData(compressionQuality: 0.9) { ref.putData(data, metadata: nil) }
|
|
}
|
|
}
|
|
|
|
class CloudEngine {
|
|
static var db: Firestore? {
|
|
return FirebaseApp.app() != nil ? Firestore.firestore() : nil
|
|
}
|
|
static func signInSilently() {
|
|
guard FirebaseApp.app() != nil else { return }
|
|
if Auth.auth().currentUser == nil { Auth.auth().signInAnonymously() }
|
|
}
|
|
|
|
static func save(card: SavedCard) async {
|
|
guard let db = db, let uid = Auth.auth().currentUser?.uid else { return }
|
|
let data: [String: Any] = [
|
|
"name": card.name,
|
|
"set": card.setCode,
|
|
"num": card.collectorNumber,
|
|
"val": card.currentValuation ?? 0.0,
|
|
"cond": card.condition,
|
|
"foil": card.foilType,
|
|
"coll": card.collectionName,
|
|
"loc": card.storageLocation,
|
|
"grade": card.grade ?? "",
|
|
"svc": card.gradingService ?? "",
|
|
"cert": card.certNumber ?? "",
|
|
"date": card.dateAdded,
|
|
"curr": card.currencyCode ?? "USD",
|
|
"rarity": card.rarity ?? "",
|
|
"colors": card.colorIdentity ?? [],
|
|
"ser": card.isSerialized ?? false,
|
|
"img": card.imageFileName,
|
|
"custom": card.isCustomValuation
|
|
]
|
|
do {
|
|
try await db.collection("users").document(uid).collection("inventory").document(card.id.uuidString).setData(data, merge: true)
|
|
} catch { print("Cloud Save Error: \(error)") }
|
|
}
|
|
|
|
static func delete(card: SavedCard) async {
|
|
guard let db = db, let uid = Auth.auth().currentUser?.uid else { return }
|
|
do {
|
|
try await db.collection("users").document(uid).collection("inventory").document(card.id.uuidString).delete()
|
|
} catch { print("Cloud Delete Error: \(error)") }
|
|
}
|
|
|
|
static func batchUpdatePrices(cards: [SavedCard]) async {
|
|
guard let db = db, let uid = Auth.auth().currentUser?.uid else { return }
|
|
let ref = db.collection("users").document(uid).collection("inventory")
|
|
|
|
let chunks = stride(from: 0, to: cards.count, by: 400).map { Array(cards[$0..<min($0 + 400, cards.count)]) }
|
|
for chunk in chunks {
|
|
let batch = db.batch()
|
|
for card in chunk {
|
|
let data: [String: Any] = [
|
|
"val": card.currentValuation ?? 0.0,
|
|
"curr": card.currencyCode ?? "USD",
|
|
"rarity": card.rarity ?? "",
|
|
"colors": card.colorIdentity ?? []
|
|
]
|
|
batch.setData(data, forDocument: ref.document(card.id.uuidString), merge: true)
|
|
}
|
|
do {
|
|
try await batch.commit()
|
|
} catch { print("Batch Update Error: \(error)") }
|
|
}
|
|
}
|
|
}
|
|
|
|
class ExportEngine {
|
|
static func generateString(cards: [SavedCard], format: ExportFormat) -> String {
|
|
if format == .csv {
|
|
func cleanCSV(_ text: String) -> String { return text.replacingOccurrences(of: "\"", with: "\"\"") }
|
|
var csv = "Count,Name,Set,Number,Condition,Foil,Price,Serialized\n"
|
|
for card in cards {
|
|
let ser = (card.isSerialized ?? false) ? "Yes" : "No"
|
|
let line = "1,\"\(cleanCSV(card.name))\",\(card.setCode),\(card.collectorNumber),\(card.condition),\(card.foilType),\(card.currentValuation ?? 0.0),\(ser)\n"
|
|
csv.append(line)
|
|
}
|
|
return csv
|
|
} else if format == .mtgo {
|
|
return cards.map { "1 \($0.name)" }.joined(separator: "\n")
|
|
} else {
|
|
// Arena
|
|
return cards.map { "1 \($0.name) (\($0.setCode)) \($0.collectorNumber)" }.joined(separator: "\n")
|
|
}
|
|
}
|
|
|
|
static func generate(cards: [SavedCard], format: ExportFormat) -> URL? {
|
|
if format == .insurance { return generatePDF(cards: cards) }
|
|
|
|
let text = generateString(cards: cards, format: format)
|
|
let filename = format == .csv ? "Collection.csv" : (format == .mtgo ? "MTGO_List.txt" : "Arena_Decklist.txt")
|
|
let path = FileManager.default.temporaryDirectory.appendingPathComponent(filename)
|
|
try? text.write(to: path, atomically: true, encoding: .utf8)
|
|
return path
|
|
}
|
|
|
|
private static func generatePDF(cards: [SavedCard]) -> URL? {
|
|
let fmt = UIGraphicsPDFRendererFormat()
|
|
fmt.documentInfo = [kCGPDFContextCreator: "IYmtg"] as [String: Any]
|
|
let url = FileManager.default.temporaryDirectory.appendingPathComponent("Insurance.pdf")
|
|
|
|
let totalVal = cards.reduce(0) { $0 + ($1.currentValuation ?? 0) }
|
|
let count = cards.count
|
|
|
|
UIGraphicsPDFRenderer(bounds: CGRect(x: 0, y: 0, width: 612, height: 792), format: fmt).writePDF(to: url) { ctx in
|
|
var pageY: CGFloat = 50
|
|
let headerAttrs: [NSAttributedString.Key: Any] = [.font: UIFont.boldSystemFont(ofSize: 24)]
|
|
let subHeaderAttrs: [NSAttributedString.Key: Any] = [.font: UIFont.boldSystemFont(ofSize: 14)]
|
|
let textAttrs: [NSAttributedString.Key: Any] = [.font: UIFont.systemFont(ofSize: 12)]
|
|
|
|
func drawHeader() {
|
|
"Insurance Schedule - \(Date().formatted(date: .abbreviated, time: .shortened))".draw(at: CGPoint(x: 50, y: 50), withAttributes: headerAttrs)
|
|
}
|
|
|
|
func drawColumnHeaders(y: CGFloat) {
|
|
let hAttrs: [NSAttributedString.Key: Any] = [.font: UIFont.boldSystemFont(ofSize: 10), .foregroundColor: UIColor.darkGray]
|
|
"CARD DETAILS".draw(at: CGPoint(x: 100, y: y), withAttributes: hAttrs)
|
|
"SET / #".draw(at: CGPoint(x: 310, y: y), withAttributes: hAttrs)
|
|
"COND".draw(at: CGPoint(x: 420, y: y), withAttributes: hAttrs)
|
|
"VALUE".draw(at: CGPoint(x: 520, y: y), withAttributes: hAttrs)
|
|
}
|
|
|
|
ctx.beginPage()
|
|
drawHeader()
|
|
|
|
// Summary Section
|
|
"Policy Holder: __________________________".draw(at: CGPoint(x: 50, y: 90), withAttributes: subHeaderAttrs)
|
|
"Total Items: \(count)".draw(at: CGPoint(x: 50, y: 115), withAttributes: subHeaderAttrs)
|
|
"Total Value: \(cards.first?.currencyCode == "EUR" ? "€" : "$")\(String(format: "%.2f", totalVal))".draw(at: CGPoint(x: 200, y: 115), withAttributes: subHeaderAttrs)
|
|
drawColumnHeaders(y: 135)
|
|
|
|
pageY = 150
|
|
|
|
for card in cards {
|
|
// Check for page break (Row height increased to 60 for image)
|
|
if pageY + 65 > 740 {
|
|
ctx.beginPage()
|
|
drawHeader()
|
|
drawColumnHeaders(y: 75)
|
|
pageY = 90
|
|
}
|
|
|
|
// Column 0: Image
|
|
if let img = ImageManager.load(name: card.imageFileName) {
|
|
img.draw(in: CGRect(x: 50, y: pageY, width: 40, height: 56))
|
|
}
|
|
|
|
let textY = pageY + 20
|
|
// Column 1: Name (Truncate if long)
|
|
let name = "\(card.name)\((card.isSerialized ?? false) ? " [S]" : "")"
|
|
name.draw(in: CGRect(x: 100, y: textY, width: 200, height: 18), withAttributes: textAttrs)
|
|
// Column 2: Set
|
|
let setInfo = "\(card.setCode.uppercased()) #\(card.collectorNumber)"
|
|
setInfo.draw(at: CGPoint(x: 310, y: textY), withAttributes: textAttrs)
|
|
// Column 3: Condition (Short code)
|
|
let cond = card.condition.components(separatedBy: "(").last?.replacingOccurrences(of: ")", with: "") ?? card.condition
|
|
cond.draw(at: CGPoint(x: 420, y: textY), withAttributes: textAttrs)
|
|
// Column 4: Value
|
|
let val = "\(card.currencyCode == "EUR" ? "€" : "$")\(String(format: "%.2f", card.currentValuation ?? 0.0))"
|
|
val.draw(at: CGPoint(x: 520, y: textY), withAttributes: textAttrs)
|
|
|
|
pageY += 65
|
|
}
|
|
|
|
// Condensed Summary Section
|
|
ctx.beginPage()
|
|
drawHeader()
|
|
"Condensed Manifest".draw(at: CGPoint(x: 50, y: 90), withAttributes: subHeaderAttrs)
|
|
pageY = 120
|
|
|
|
for card in cards {
|
|
if pageY > 740 {
|
|
ctx.beginPage()
|
|
drawHeader()
|
|
"Condensed Manifest (Cont.)".draw(at: CGPoint(x: 50, y: 90), withAttributes: subHeaderAttrs)
|
|
pageY = 120
|
|
}
|
|
|
|
let line = "\(card.name) (\(card.setCode) #\(card.collectorNumber))"
|
|
line.draw(in: CGRect(x: 50, y: pageY, width: 400, height: 18), withAttributes: textAttrs)
|
|
|
|
let val = "\(card.currencyCode == "EUR" ? "€" : "$")\(String(format: "%.2f", card.currentValuation ?? 0.0))"
|
|
val.draw(at: CGPoint(x: 500, y: pageY), withAttributes: textAttrs)
|
|
pageY += 20
|
|
}
|
|
|
|
// FIX: Ensure Grand Total doesn't fall off the page
|
|
if pageY + 40 > 792 {
|
|
ctx.beginPage()
|
|
drawHeader()
|
|
pageY = 90
|
|
}
|
|
"GRAND TOTAL: \(cards.first?.currencyCode == "EUR" ? "€" : "$")\(String(format: "%.2f", totalVal))".draw(at: CGPoint(x: 400, y: pageY + 20), withAttributes: subHeaderAttrs)
|
|
}
|
|
return url
|
|
}
|
|
}
|
|
enum ExportFormat: String, CaseIterable { case insurance="PDF"; case arena="Arena"; case mtgo="MTGO"; case csv="CSV" }
|
|
|
|
// MARK: - 5. IMAGE MANAGER
|
|
class ImageManager {
|
|
static var dir: URL {
|
|
if FileManager.default.ubiquityIdentityToken != nil {
|
|
return FileManager.default.url(forUbiquityContainerIdentifier: nil)?.appendingPathComponent("Documents") ?? FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
|
|
}
|
|
return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
|
|
}
|
|
|
|
static func save(_ img: UIImage, name: String) throws {
|
|
let url = dir.appendingPathComponent(name)
|
|
if !FileManager.default.fileExists(atPath: dir.path) {
|
|
try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
|
|
}
|
|
|
|
let maxSize: CGFloat = 1024
|
|
var actualImg = img
|
|
if img.size.width > maxSize || img.size.height > maxSize {
|
|
let scale = maxSize / max(img.size.width, img.size.height)
|
|
let newSize = CGSize(width: img.size.width * scale, height: img.size.height * scale)
|
|
let format = UIGraphicsImageRendererFormat()
|
|
format.scale = 1
|
|
let renderer = UIGraphicsImageRenderer(size: newSize, format: format)
|
|
actualImg = renderer.image { _ in img.draw(in: CGRect(origin: .zero, size: newSize)) }
|
|
}
|
|
|
|
guard let data = actualImg.jpegData(compressionQuality: 0.7) else { return }
|
|
try data.write(to: url, options: .atomic)
|
|
}
|
|
|
|
static func load(name: String) -> UIImage? {
|
|
let p = dir.appendingPathComponent(name)
|
|
if FileManager.default.fileExists(atPath: p.path) { return UIImage(contentsOfFile: p.path) }
|
|
try? FileManager.default.startDownloadingUbiquitousItem(at: p)
|
|
return UIImage(contentsOfFile: p.path)
|
|
}
|
|
|
|
static func migrateToCloud() {
|
|
guard let cloudURL = FileManager.default.url(forUbiquityContainerIdentifier: nil)?.appendingPathComponent("Documents") else { return }
|
|
let localURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
|
|
|
|
if !FileManager.default.fileExists(atPath: cloudURL.path) { try? FileManager.default.createDirectory(at: cloudURL, withIntermediateDirectories: true) }
|
|
|
|
let fileManager = FileManager.default
|
|
guard let files = try? fileManager.contentsOfDirectory(at: localURL, includingPropertiesForKeys: nil) else { return }
|
|
|
|
for file in files {
|
|
if file.pathExtension == "jpg" {
|
|
let dest = cloudURL.appendingPathComponent(file.lastPathComponent)
|
|
if !fileManager.fileExists(atPath: dest.path) { try? fileManager.moveItem(at: file, to: dest) }
|
|
}
|
|
}
|
|
}
|
|
|
|
static func delete(name: String) async {
|
|
let url = dir.appendingPathComponent(name)
|
|
try? FileManager.default.removeItem(at: url)
|
|
}
|
|
|
|
static func cleanupOrphans(activeImages: Set<String>) {
|
|
Task.detached {
|
|
guard !activeImages.isEmpty else { return }
|
|
let fileManager = FileManager.default
|
|
guard let files = try? fileManager.contentsOfDirectory(at: dir, includingPropertiesForKeys: [.contentModificationDateKey]) else { return }
|
|
|
|
for fileURL in files {
|
|
if fileURL.pathExtension == "jpg" {
|
|
if !activeImages.contains(fileURL.lastPathComponent) {
|
|
if let attrs = try? fileManager.attributesOfItem(atPath: fileURL.path),
|
|
let date = attrs[.modificationDate] as? Date,
|
|
Date().timeIntervalSince(date) > 3600 {
|
|
try? fileManager.removeItem(at: fileURL)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ClusterEngine {
|
|
static func refine(candidates: [CardMetadata]) -> String? {
|
|
// Weighted voting: 1st candidate = 3 pts, 2nd = 2 pts, others = 1 pt
|
|
var scores: [String: Int] = [:]
|
|
for (index, card) in candidates.prefix(5).enumerated() {
|
|
let weight = max(1, 3 - index)
|
|
scores[card.setCode, default: 0] += weight
|
|
}
|
|
return scores.sorted { $0.value > $1.value }.first?.key
|
|
}
|
|
}
|
|
|
|
// MARK: - 10. SET SYMBOL ENGINE
|
|
class SetSymbolEngine {
|
|
static var model: VNCoreMLModel? = {
|
|
guard AppConfig.enableSetSymbolDetection else { return nil }
|
|
return ModelManager.shared.getModel(name: "IYmtgSetClassifier")
|
|
}()
|
|
|
|
static func recognizeSet(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> String? {
|
|
guard let model = model else { return nil }
|
|
let request = VNCoreMLRequest(model: model)
|
|
request.imageCropAndScaleOption = .scaleFill
|
|
|
|
// FIX: Use regionOfInterest (Normalized 0..1, Bottom-Left origin)
|
|
// Target: x=0.85 (Right), y=0.36 (Mid-Lower), w=0.12, h=0.09
|
|
// Adjusted to ensure we catch the symbol which sits on the type line (approx y=0.40)
|
|
request.regionOfInterest = CGRect(x: 0.85, y: 0.36, width: 0.12, height: 0.09)
|
|
|
|
let handler = VNImageRequestHandler(cgImage: image, orientation: orientation, options: [:])
|
|
|
|
do {
|
|
try handler.perform([request])
|
|
guard let results = request.results as? [VNClassificationObservation], let top = results.first else { return nil }
|
|
return top.confidence > 0.6 ? top.identifier : nil
|
|
} catch { return nil }
|
|
}
|
|
}
|
|
|
|
// MARK: - 11. BORDER DETECTOR
|
|
class BorderDetector {
|
|
enum BorderColor { case black, white, gold, other }
|
|
|
|
static func detect(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> BorderColor {
|
|
// Sample pixels from the edge (e.g., 5% margin)
|
|
let context = SharedEngineResources.context
|
|
let ciImage = CIImage(cgImage: image).oriented(orientation)
|
|
let width = ciImage.extent.width
|
|
let height = ciImage.extent.height
|
|
|
|
// Crop a small strip from the left edge
|
|
let cropRect = CGRect(x: CGFloat(width) * 0.02, y: CGFloat(height) * 0.4, width: CGFloat(width) * 0.05, height: CGFloat(height) * 0.2)
|
|
let vector = CIVector(cgRect: cropRect)
|
|
let filter = CIFilter(name: "CIAreaAverage", parameters: [kCIInputImageKey: ciImage, kCIInputExtentKey: vector])
|
|
|
|
guard let output = filter?.outputImage else { return .other }
|
|
var bitmap = [UInt8](repeating: 0, count: 4)
|
|
context.render(output, toBitmap: &bitmap, rowBytes: 4, bounds: CGRect(x: 0, y: 0, width: 1, height: 1), format: .RGBA8, colorSpace: nil)
|
|
|
|
let r = Int(bitmap[0])
|
|
let g = Int(bitmap[1])
|
|
let b = Int(bitmap[2])
|
|
let brightness = (r + g + b) / 3
|
|
|
|
// Gold/Yellow detection (World Champ Decks): High Red/Green, Low Blue
|
|
if r > 140 && g > 120 && b < 100 && r > b + 40 { return .gold }
|
|
|
|
if brightness < 60 { return .black }
|
|
if brightness > 180 { return .white }
|
|
return .other
|
|
}
|
|
}
|
|
|
|
// MARK: - 12. LIST SYMBOL DETECTOR
|
|
class ListSymbolDetector {
|
|
static func hasListSymbol(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> Bool {
|
|
// The "List" / "Mystery" symbol is a small white icon in the bottom-left corner.
|
|
// It sits roughly at x: 3-7%, y: 93-97% of the card frame.
|
|
|
|
let context = SharedEngineResources.context
|
|
let ciImage = CIImage(cgImage: image).oriented(orientation)
|
|
let width = ciImage.extent.width
|
|
let height = ciImage.extent.height
|
|
|
|
// FIX: CIImage uses Bottom-Left origin. The List symbol is Bottom-Left.
|
|
// y: 0.03 is Bottom. y: 0.93 is Top.
|
|
let cropRect = CGRect(x: width * 0.03, y: height * 0.03, width: width * 0.05, height: height * 0.04)
|
|
let vector = CIVector(cgRect: cropRect)
|
|
|
|
// Calculate average brightness in this spot
|
|
guard let filter = CIFilter(name: "CIAreaAverage", parameters: [kCIInputImageKey: ciImage, kCIInputExtentKey: vector]),
|
|
let output = filter.outputImage else { return false }
|
|
|
|
var bitmap = [UInt8](repeating: 0, count: 4)
|
|
context.render(output, toBitmap: &bitmap, rowBytes: 4, bounds: CGRect(x: 0, y: 0, width: 1, height: 1), format: .RGBA8, colorSpace: nil)
|
|
|
|
// A white symbol on a black border will significantly raise the average brightness compared to a pure black border.
|
|
// Pure black ~ 0-20. With symbol ~ 80-150.
|
|
let brightness = (Int(bitmap[0]) + Int(bitmap[1]) + Int(bitmap[2])) / 3
|
|
return brightness > 60
|
|
}
|
|
}
|
|
|
|
// MARK: - 13. CORNER DETECTOR (Alpha vs Beta)
|
|
class CornerDetector {
|
|
static func isAlphaCorner(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> Bool {
|
|
// Alpha corners are 2mm radius (very round). Beta are 1mm (standard).
|
|
// We analyze the top-left corner (4% of width).
|
|
// If significantly more "background" (non-black) pixels exist in the corner square, it's Alpha.
|
|
|
|
let context = SharedEngineResources.context
|
|
let ciImage = CIImage(cgImage: image).oriented(orientation)
|
|
let width = ciImage.extent.width
|
|
let height = ciImage.extent.height
|
|
|
|
let cornerSize = Int(Double(width) * 0.04)
|
|
// FIX: Analyze Top-Left corner (y is at top in CIImage coordinates)
|
|
let cropRect = CGRect(x: 0, y: CGFloat(height) - CGFloat(cornerSize), width: CGFloat(cornerSize), height: CGFloat(cornerSize))
|
|
|
|
let cropped = ciImage.cropped(to: cropRect)
|
|
|
|
var bitmap = [UInt8](repeating: 0, count: cornerSize * cornerSize * 4)
|
|
context.render(cropped, toBitmap: &bitmap, rowBytes: cornerSize * 4, bounds: cropRect, format: .RGBA8, colorSpace: nil)
|
|
|
|
var backgroundPixelCount = 0
|
|
let totalPixels = cornerSize * cornerSize
|
|
|
|
for i in stride(from: 0, to: bitmap.count, by: 4) {
|
|
let r = Int(bitmap[i])
|
|
let g = Int(bitmap[i+1])
|
|
let b = Int(bitmap[i+2])
|
|
let brightness = (r + g + b) / 3
|
|
|
|
// Assuming Black Border is < 60 brightness.
|
|
// If pixel is brighter, it's likely the background revealed by the round corner.
|
|
if brightness > 80 { backgroundPixelCount += 1 }
|
|
}
|
|
|
|
// Alpha corners reveal roughly 30-40% background in a tight corner crop. Beta reveals < 20%.
|
|
return Double(backgroundPixelCount) / Double(totalPixels) > 0.25
|
|
}
|
|
}
|
|
|
|
// MARK: - 14. SATURATION DETECTOR (Unlimited vs Revised)
|
|
class SaturationDetector {
|
|
static func analyze(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> Double {
|
|
// Crop to center 50% to analyze artwork saturation, ignoring borders
|
|
let ciImage = CIImage(cgImage: image).oriented(orientation)
|
|
let width = ciImage.extent.width
|
|
let height = ciImage.extent.height
|
|
let cropRect = CGRect(x: width * 0.25, y: height * 0.25, width: width * 0.5, height: height * 0.5)
|
|
|
|
let vector = CIVector(cgRect: cropRect)
|
|
guard let filter = CIFilter(name: "CIAreaAverage", parameters: [kCIInputImageKey: ciImage, kCIInputExtentKey: vector]),
|
|
let output = filter.outputImage else { return 0 }
|
|
|
|
var bitmap = [UInt8](repeating: 0, count: 4)
|
|
let context = SharedEngineResources.context
|
|
context.render(output, toBitmap: &bitmap, rowBytes: 4, bounds: CGRect(x: 0, y: 0, width: 1, height: 1), format: .RGBA8, colorSpace: nil)
|
|
|
|
// Simple Saturation approximation: (Max - Min) / Max
|
|
let r = Double(bitmap[0]) / 255.0; let g = Double(bitmap[1]) / 255.0; let b = Double(bitmap[2]) / 255.0
|
|
let maxC = max(r, max(g, b)); let minC = min(r, min(g, b))
|
|
|
|
return maxC == 0 ? 0 : (maxC - minC) / maxC
|
|
}
|
|
}
|
|
|
|
// MARK: - 15. STAMP DETECTOR (Promos)
|
|
class StampDetector {
|
|
static var model: VNCoreMLModel? = {
|
|
guard AppConfig.enableStampDetection else { return nil }
|
|
return ModelManager.shared.getModel(name: "IYmtgStampClassifier")
|
|
}()
|
|
|
|
static func hasStamp(image: CGImage, orientation: CGImagePropertyOrientation = .up) -> Bool {
|
|
guard let model = model else { return false }
|
|
let request = VNCoreMLRequest(model: model)
|
|
request.imageCropAndScaleOption = .scaleFill
|
|
let handler = VNImageRequestHandler(cgImage: image, orientation: orientation, options: [:])
|
|
try? handler.perform([request])
|
|
guard let results = request.results as? [VNClassificationObservation], let top = results.first else { return false }
|
|
return top.identifier == "Stamped" && top.confidence > 0.8
|
|
}
|
|
}
|
|
|
|
// MARK: - 6. FOIL ENGINE
|
|
actor FoilEngine {
|
|
private var frameCounter = 0
|
|
private var lowConfidenceStreak = 0
|
|
static var model: VNCoreMLModel? = {
|
|
guard AppConfig.enableFoilDetection else { return nil }
|
|
return ModelManager.shared.getModel(name: "IYmtgFoilClassifier")
|
|
}()
|
|
|
|
private lazy var request: VNCoreMLRequest? = {
|
|
guard let model = FoilEngine.model else { return nil }
|
|
let req = VNCoreMLRequest(model: model)
|
|
req.imageCropAndScaleOption = .scaleFill
|
|
return req
|
|
}()
|
|
|
|
func addFrame(_ image: CGImage, orientation: CGImagePropertyOrientation = .up) -> String? {
|
|
frameCounter += 1
|
|
// SAFETY: Prevent integer overflow in long-running sessions
|
|
if frameCounter > 1000 { frameCounter = 0 }
|
|
if frameCounter % 5 != 0 { return nil }
|
|
guard let request = self.request else { return AppConfig.Defaults.defaultFoil }
|
|
|
|
let handler = VNImageRequestHandler(cgImage: image, orientation: orientation, options: [:])
|
|
|
|
do {
|
|
try handler.perform([request])
|
|
guard let results = request.results as? [VNClassificationObservation], let top = results.first else { return AppConfig.Defaults.defaultFoil }
|
|
|
|
if top.confidence > 0.85 {
|
|
lowConfidenceStreak = 0
|
|
return top.identifier
|
|
} else {
|
|
lowConfidenceStreak += 1
|
|
if lowConfidenceStreak >= 3 {
|
|
return AppConfig.Defaults.defaultFoil
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
} catch { return AppConfig.Defaults.defaultFoil }
|
|
}
|
|
}
|
|
|
|
// MARK: - 7. PERSISTENCE ACTOR (V1.1.0: iCloud Migration)
|
|
actor PersistenceActor {
|
|
static let shared = PersistenceActor()
|
|
private let fileName = "user_collection.json"
|
|
private let backupName = "user_collection.bak"
|
|
|
|
// Helper to access cloud URL for migration checks
|
|
private var cloudURL: URL? { FileManager.default.url(forUbiquityContainerIdentifier: nil)?.appendingPathComponent("Documents") }
|
|
private var localURL: URL { FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0] }
|
|
|
|
private var fileURL: URL { ImageManager.dir.appendingPathComponent(fileName) }
|
|
private var backupURL: URL { ImageManager.dir.appendingPathComponent(backupName) }
|
|
|
|
init() {}
|
|
|
|
func save(_ cards: [SavedCard]) {
|
|
do {
|
|
let data = try JSONEncoder().encode(cards)
|
|
if FileManager.default.fileExists(atPath: fileURL.path) {
|
|
try? FileManager.default.removeItem(at: backupURL)
|
|
try? FileManager.default.copyItem(at: fileURL, to: backupURL)
|
|
}
|
|
try data.write(to: fileURL, options: .atomic)
|
|
} catch { print("Save failed: \(error)") }
|
|
}
|
|
|
|
func load() -> [SavedCard] {
|
|
|
|
migrateIfNeeded()
|
|
try? FileManager.default.startDownloadingUbiquitousItem(at: fileURL)
|
|
|
|
if let data = try? Data(contentsOf: fileURL), let list = try? JSONDecoder().decode([SavedCard].self, from: data) { return list }
|
|
if let data = try? Data(contentsOf: backupURL), let list = try? JSONDecoder().decode([SavedCard].self, from: data) { return list }
|
|
return []
|
|
}
|
|
|
|
private func migrateIfNeeded() {
|
|
guard let cloud = cloudURL else { return }
|
|
let cloudFile = cloud.appendingPathComponent(fileName)
|
|
let localFile = localURL.appendingPathComponent(fileName)
|
|
|
|
if !FileManager.default.fileExists(atPath: cloud.path) {
|
|
try? FileManager.default.createDirectory(at: cloud, withIntermediateDirectories: true)
|
|
}
|
|
|
|
if FileManager.default.fileExists(atPath: localFile.path) && !FileManager.default.fileExists(atPath: cloudFile.path) {
|
|
try? FileManager.default.moveItem(at: localFile, to: cloudFile)
|
|
print("MIGRATION: Moved local DB to iCloud.")
|
|
ImageManager.migrateToCloud()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - 8. NETWORK MONITOR
|
|
class NetworkMonitor: ObservableObject {
|
|
static let shared = NetworkMonitor()
|
|
private let monitor = NWPathMonitor()
|
|
@Published var isConnected = true
|
|
init() {
|
|
monitor.pathUpdateHandler = { path in DispatchQueue.main.async { self.isConnected = path.status == .satisfied } }
|
|
monitor.start(queue: DispatchQueue.global(qos: .background))
|
|
}
|
|
}
|
|
|
|
// MARK: - 9. REVIEW ENGINE
|
|
class ReviewEngine {
|
|
static func logScan() {
|
|
let count = UserDefaults.standard.integer(forKey: "scanCount") + 1
|
|
UserDefaults.standard.set(count, forKey: "scanCount")
|
|
if count == 20 || count == 100 {
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
|
|
if let scene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
|
|
SKStoreReviewController.requestReview(in: scene)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |