Initial commit for Leaf Lens project

Author: Navin-Rai-Developer

Leaf Lens.xcodeproj/project.pbxproj

@@ -256,6 +256,8 @@
 				DEVELOPMENT_TEAM = 7RPVG8UJGR;
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_KEY_NSCameraUsageDescription = "Leaf Leans needs camera access to identify plants";
+				INFOPLIST_KEY_NSPhotoLibraryAddUsageDescription = "Leaf Leans needs photo library access to select plant images";
 				INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES;
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
@@ -284,6 +286,8 @@
 				DEVELOPMENT_TEAM = 7RPVG8UJGR;
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_KEY_NSCameraUsageDescription = "Leaf Leans needs camera access to identify plants";
+				INFOPLIST_KEY_NSPhotoLibraryAddUsageDescription = "Leaf Leans needs photo library access to select plant images";
 				INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES;
 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;

Leaf Lens/ContentView.swift

@@ -0,0 +1,74 @@
+//
+//  DataStore.swift
+//  Leaf Lens
+//
+//  Created by Navin Rai on 26/06/25.
+//
+
+import Foundation
+import UIKit
+
+class DataStore {
+    private let observationsKey = "savedPlantObservations"
+    private let fileManager = FileManager.default
+
+    // MARK: - Observation Handling
+
+    func saveObservations(_ observations: [Observation]) {
+        if let encoded = try? JSONEncoder().encode(observations) {
+            UserDefaults.standard.set(encoded, forKey: observationsKey)
+        }
+    }
+
+    func loadObservations() -> [Observation] {
+        if let savedData = UserDefaults.standard.data(forKey: observationsKey) {
+            if let decodedObservations = try? JSONDecoder().decode([Observation].self, from: savedData) {
+                return decodedObservations
+            }
+        }
+        return []
+    }
+
+    // MARK: - Image Handling
+
+    private func getDocumentsDirectory() -> URL {
+        fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0]
+    }
+
+    func saveImageToDocumentsDirectory(image: UIImage, withName name: String) -> Bool {
+        guard let data = image.pngData() else { return false }
+        let url = getDocumentsDirectory().appendingPathComponent(name)
+        do {
+            try data.write(to: url)
+            return true
+        } catch {
+            print("Error saving image: \(error.localizedDescription)")
+            return false
+        }
+    }
+
+    func loadImageFromDocumentsDirectory(imageName: String) -> UIImage? {
+        let url = getDocumentsDirectory().appendingPathComponent(imageName)
+        guard fileManager.fileExists(atPath: url.path) else {
+            print("Image file does not exist at path: \(url.path)")
+            return nil
+        }
+        do {
+            let data = try Data(contentsOf: url)
+            return UIImage(data: data)
+        } catch {
+            print("Error loading image: \(error.localizedDescription)")
+            return nil
+        }
+    }
+
+    func deleteImageFromDocumentsDirectory(imageName: String) {
+        let fileURL = getDocumentsDirectory().appendingPathComponent(imageName)
+        do {
+            try fileManager.removeItem(at: fileURL)
+            print("Deleted image: \(fileURL.lastPathComponent)")
+        } catch {
+            print("Could not delete image: \(error.localizedDescription)")
+        }
+    }
+}

Leaf Lens/Models/DataStore.swift

@@ -0,0 +1,47 @@
+//
+//  Model.swift
+//  Leaf Lens
+//
+//  Created by Navin Rai on 26/06/25.
+//
+
+import Foundation
+import UIKit // UIImage ke liye
+
+struct Observation: Identifiable, Codable {
+    var id = UUID() // Unique ID har observation ke liye
+    let imageName: String // Image ko file system mein save karne ke liye naam
+    let plantName: String
+    let confidence: String
+    let date: Date // Date of Scan
+
+    // Codable protocols ke liye custom initializers
+    enum CodingKeys: String, CodingKey {
+        case id, imageName, plantName, confidence, date
+    }
+
+    init(imageName: String, plantName: String, confidence: String, date: Date) {
+        self.imageName = imageName
+        self.plantName = plantName
+        self.confidence = confidence
+        self.date = date
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        id = try container.decode(UUID.self, forKey: .id)
+        imageName = try container.decode(String.self, forKey: .imageName)
+        plantName = try container.decode(String.self, forKey: .plantName)
+        confidence = try container.decode(String.self, forKey: .confidence)
+        date = try container.decode(Date.self, forKey: .date)
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(id, forKey: .id)
+        try container.encode(imageName, forKey: .imageName)
+        try container.encode(plantName, forKey: .plantName)
+        try container.encode(confidence, forKey: .confidence)
+        try container.encode(date, forKey: .date)
+    }
+}

Leaf Lens/Models/Model.swift

@@ -0,0 +1,146 @@
+//
+//  ContentViewModel.swift
+//  Leaf Lens
+//
+//  Created by Navin Rai on 26/06/25.
+//
+
+import Foundation
+import SwiftUI
+import CoreML
+import Vision
+
+class ContentViewModel: ObservableObject {
+    @Published var selectedImage: UIImage?
+    @Published var plantName: String = "Identified As: "
+    @Published var confidence: String = "Confidence: "
+    @Published var showingImagePicker: Bool = false
+    @Published var showingAlert: Bool = false
+    @Published var alertMessage: String = ""
+    @Published var navigateToSavedObservations: Bool = false
+
+    private let dataStore = DataStore() // DataStore instance
+
+    // MARK: - Image Selection & Core ML Logic
+
+    func processImage() {
+        guard let inputImage = selectedImage else {
+            plantName = "Identified As: No image selected"
+            confidence = "Confidence: N/A"
+            return
+        }
+
+        guard let ciImage = CIImage(image: inputImage) else {
+            alertMessage = "Could not convert UIImage to CIImage."
+            showingAlert = true
+            return
+        }
+
+        // Replace MobileNetV2() with your actual Core ML model name
+        guard let model = try? VNCoreMLModel(for: MobileNetV2().model) else {
+            alertMessage = "Failed to load Core ML model. Make sure the .mlmodel file is added correctly and target membership is set."
+            showingAlert = true
+            return
+        }
+
+        let request = VNCoreMLRequest(model: model) { [weak self] request, error in
+            guard let self = self else { return }
+
+            if let error = error {
+                DispatchQueue.main.async {
+                    self.alertMessage = "Image classification failed: \(error.localizedDescription)"
+                    self.showingAlert = true
+                }
+                return
+            }
+
+            guard let observations = request.results as? [VNClassificationObservation] else {
+                DispatchQueue.main.async {
+                    self.alertMessage = "Model returned no observations."
+                    self.showingAlert = true
+                }
+                return
+            }
+
+            if let bestResult = observations.first {
+                let identifier = bestResult.identifier.capitalized.replacingOccurrences(of: "_", with: " ")
+                let confidenceScore = String(format: "%.2f%%", bestResult.confidence * 100)
+                
+                DispatchQueue.main.async {
+                    self.plantName = "Identified As: \(identifier)"
+                    self.confidence = "Confidence: \(confidenceScore)"
+                }
+            } else {
+                DispatchQueue.main.async {
+                    self.plantName = "Identified As: Unknown"
+                    self.confidence = "Confidence: Low"
+                }
+            }
+        }
+
+        let handler = VNImageRequestHandler(ciImage: ciImage)
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                try handler.perform([request])
+            } catch {
+                DispatchQueue.main.async {
+                    self.alertMessage = "Failed to perform classification: \(error.localizedDescription)"
+                    self.showingAlert = true
+                }
+            }
+        }
+    }
+
+    // MARK: - Save Logic
+
+    func saveCurrentObservation() {
+        guard let imageToSave = selectedImage,
+              plantName != "Identified As: ",
+              plantName != "Identified As: No image selected",
+              plantName != "Identified As: Unknown" else {
+            alertMessage = "No valid plant identified to save."
+            showingAlert = true
+            return
+        }
+
+        // Image ko file system mein save karein
+        let imageName = UUID().uuidString + ".png" // Har baar ek naya unique filename
+        if dataStore.saveImageToDocumentsDirectory(image: imageToSave, withName: imageName) {
+            var allObservations = dataStore.loadObservations() // Load existing
+            let newObservation = Observation(
+                imageName: imageName,
+                plantName: plantName,
+                confidence: confidence,
+                date: Date()
+            )
+            allObservations.append(newObservation)
+            dataStore.saveObservations(allObservations) // Save updated list
+            alertMessage = "Result saved successfully!"
+            showingAlert = true
+            
+            // ---  UI State Reset ---
+        
+            self.selectedImage = nil
+            self.plantName = "Identified As: "
+            self.confidence = "Confidence: "
+            
+        } else {
+            alertMessage = "Failed to save image."
+            showingAlert = true
+        }
+    }
+
+    // MARK: - UI Actions (called by View)
+    
+    func openImagePicker() {
+        showingImagePicker = true
+    }
+    
+    func imagePickedAndProcessed() {
+        processImage()
+    }
+    
+    func viewSavedResults() {
+        navigateToSavedObservations = true
+    }
+}

Leaf Lens/Resources/MobileNetV2.mlmodel

@@ -0,0 +1,43 @@
+//
+//  ObservationViewModel.swift
+//  Leaf Lens
+//
+//  Created by Navin Rai on 26/06/25.
+//
+
+import Foundation
+import UIKit
+
+class SavedObservationsViewModel: ObservableObject {
+    @Published var observations: [Observation] = []
+    private let dataStore = DataStore()
+
+    func loadObservations() {
+        observations = dataStore.loadObservations()
+    }
+
+    func deleteObservation(at offsets: IndexSet) {
+        // Since we display observations.reversed(), need to adjust indices for deletion on original array
+        let originalIndicesToDelete = offsets.map { observations.count - 1 - $0 }
+        
+        // Delete images first
+        for index in originalIndicesToDelete {
+            let observationToDelete = observations[index]
+            dataStore.deleteImageFromDocumentsDirectory(imageName: observationToDelete.imageName)
+        }
+        
+        // Remove from the array and save
+        var currentObservations = dataStore.loadObservations()
+        // Filter out observations based on the IDs of those to be deleted
+        let idsToDelete = originalIndicesToDelete.map { observations[$0].id }
+        currentObservations.removeAll { idsToDelete.contains($0.id) }
+        
+        dataStore.saveObservations(currentObservations)
+        loadObservations() // Reload to reflect changes
+    }
+    
+    // This is for the ObservationRow to load its image
+    func loadImageForObservation(_ observation: Observation) -> UIImage? {
+        dataStore.loadImageFromDocumentsDirectory(imageName: observation.imageName)
+    }
+}