jFc

.idea/deploymentTargetSelector.xml

@@ -4,7 +4,7 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2026-01-25T20:45:06.118763497Z">
+        <DropdownSelection timestamp="2026-01-26T02:23:12.309011764Z">
           <Target type="DEFAULT_BOOT">
             <handle>
               <DeviceId pluginId="LocalEmulator" identifier="path=/home/genki/.android/avd/Medium_Phone.avd" />

app/build.gradle.kts

@@ -48,6 +48,9 @@ dependencies {
     implementation(libs.androidx.lifecycle.viewmodel.compose)
     implementation(libs.androidx.activity.compose)
 
+    // DataStore Preferences
+    implementation("androidx.datastore:datastore-preferences:1.1.1")
+
     // Compose
     implementation(platform(libs.androidx.compose.bom))
     implementation(libs.androidx.compose.ui)

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageDao.kt

@@ -66,6 +66,9 @@ interface ImageDao {
     @Query("SELECT * FROM images WHERE imageId = :imageId")
     suspend fun getImageById(imageId: String): ImageEntity?
 
+    @Query("SELECT * FROM images WHERE imageUri = :uri LIMIT 1")
+    suspend fun getImageByUri(uri: String): ImageEntity?
+
     /**
      * Stream images ordered by capture time (newest first).
      *

app/src/main/java/com/placeholder/sherpai2/data/repository/Facerecognitionrepository.kt

@@ -2,8 +2,10 @@ package com.placeholder.sherpai2.data.repository
 
 import android.content.Context
 import android.graphics.Bitmap
+import android.util.Log
 import com.placeholder.sherpai2.data.local.dao.FaceModelDao
 import com.placeholder.sherpai2.data.local.dao.ImageDao
+import com.placeholder.sherpai2.data.local.dao.PersonAgeTagDao
 import com.placeholder.sherpai2.data.local.dao.PersonDao
 import com.placeholder.sherpai2.data.local.dao.PhotoFaceTagDao
 import com.placeholder.sherpai2.data.local.entity.*
@@ -31,8 +33,12 @@ class FaceRecognitionRepository @Inject constructor(
     private val personDao: PersonDao,
     private val imageDao: ImageDao,
     private val faceModelDao: FaceModelDao,
-    private val photoFaceTagDao: PhotoFaceTagDao
+    private val photoFaceTagDao: PhotoFaceTagDao,
+    private val personAgeTagDao: PersonAgeTagDao
 ) {
+    companion object {
+        private const val TAG = "FaceRecognitionRepo"
+    }
 
     private val faceNetModel by lazy { FaceNetModel(context) }
 
@@ -181,12 +187,15 @@ class FaceRecognitionRepository @Inject constructor(
             var highestSimilarity = threshold
 
             for (faceModel in faceModels) {
-                val modelEmbedding = faceModel.getEmbeddingArray()
+                // Check ALL centroids for best match (critical for children with age centroids)
-                val similarity = faceNetModel.calculateSimilarity(faceEmbedding, modelEmbedding)
+                val centroids = faceModel.getCentroids()
+                val bestCentroidSimilarity = centroids.maxOfOrNull { centroid ->
+                    faceNetModel.calculateSimilarity(faceEmbedding, centroid.getEmbeddingArray())
+                } ?: 0f
 
-                if (similarity > highestSimilarity) {
+                if (bestCentroidSimilarity > highestSimilarity) {
-                    highestSimilarity = similarity
+                    highestSimilarity = bestCentroidSimilarity
-                    bestMatch = Pair(faceModel.id, similarity)
+                    bestMatch = Pair(faceModel.id, bestCentroidSimilarity)
                 }
             }
 
@@ -374,9 +383,49 @@ class FaceRecognitionRepository @Inject constructor(
             onProgress = onProgress
         )
 
+        // Generate age tags for children
+        if (person.isChild && person.dateOfBirth != null) {
+            generateAgeTagsForTraining(person, validImages)
+        }
+
         person.id
     }
 
+    /**
+     * Generate age tags from training images for a child
+     */
+    private suspend fun generateAgeTagsForTraining(
+        person: PersonEntity,
+        validImages: List<TrainingSanityChecker.ValidTrainingImage>
+    ) {
+        try {
+            val dob = person.dateOfBirth ?: return
+
+            val tags = validImages.mapNotNull { img ->
+                val imageEntity = imageDao.getImageByUri(img.uri.toString()) ?: return@mapNotNull null
+                val ageMs = imageEntity.capturedAt - dob
+                val ageYears = (ageMs / (365.25 * 24 * 60 * 60 * 1000)).toInt()
+
+                if (ageYears < 0 || ageYears > 25) return@mapNotNull null
+
+                PersonAgeTagEntity.create(
+                    personId = person.id,
+                    personName = person.name,
+                    imageId = imageEntity.imageId,
+                    ageAtCapture = ageYears,
+                    confidence = 1.0f
+                )
+            }
+
+            if (tags.isNotEmpty()) {
+                personAgeTagDao.insertTags(tags)
+                Log.d(TAG, "Created ${tags.size} age tags for ${person.name}")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to generate age tags", e)
+        }
+    }
+
     /**
      * Get face model by ID
      */

app/src/main/java/com/placeholder/sherpai2/di/RepositoryModule.kt

@@ -61,14 +61,16 @@ abstract class RepositoryModule {
             personDao: PersonDao,
             imageDao: ImageDao,
             faceModelDao: FaceModelDao,
-            photoFaceTagDao: PhotoFaceTagDao
+            photoFaceTagDao: PhotoFaceTagDao,
+            personAgeTagDao: PersonAgeTagDao
         ): FaceRecognitionRepository {
             return FaceRecognitionRepository(
                 context = context,
                 personDao = personDao,
                 imageDao = imageDao,
                 faceModelDao = faceModelDao,
-                photoFaceTagDao = photoFaceTagDao
+                photoFaceTagDao = photoFaceTagDao,
+                personAgeTagDao = personAgeTagDao
             )
         }
 

app/src/main/java/com/placeholder/sherpai2/domain/clustering/Faceclusteringservice.kt

@@ -15,6 +15,7 @@ import com.placeholder.sherpai2.data.local.dao.ImageDao
 import com.placeholder.sherpai2.data.local.entity.FaceCacheEntity
 import com.placeholder.sherpai2.data.local.entity.ImageEntity
 import com.placeholder.sherpai2.ml.FaceNetModel
+import com.placeholder.sherpai2.ml.FaceNormalizer
 import com.placeholder.sherpai2.ui.discover.DiscoverySettings
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
@@ -344,14 +345,9 @@ class FaceClusteringService @Inject constructor(
                                 }
 
                                 try {
-                                    // Crop and generate embedding
+                                    // Crop and normalize face
-                                    val faceBitmap = Bitmap.createBitmap(
+                                    val faceBitmap = FaceNormalizer.cropAndNormalize(bitmap, mlFace)
-                                        bitmap,
+                                        ?: return@forEach
-                                        mlFace.boundingBox.left.coerceIn(0, bitmap.width - 1),
-                                        mlFace.boundingBox.top.coerceIn(0, bitmap.height - 1),
-                                        mlFace.boundingBox.width().coerceAtMost(bitmap.width - mlFace.boundingBox.left),
-                                        mlFace.boundingBox.height().coerceAtMost(bitmap.height - mlFace.boundingBox.top)
-                                    )
 
                                     val embedding = faceNetModel.generateEmbedding(faceBitmap)
                                     faceBitmap.recycle()
@@ -591,13 +587,8 @@ class FaceClusteringService @Inject constructor(
                                 if (!qualityCheck.isValid) return@mapNotNull null
 
                                 try {
-                                    val faceBitmap = Bitmap.createBitmap(
+                                    val faceBitmap = FaceNormalizer.cropAndNormalize(bitmap, face)
-                                        bitmap,
+                                        ?: return@mapNotNull null
-                                        face.boundingBox.left.coerceIn(0, bitmap.width - 1),
-                                        face.boundingBox.top.coerceIn(0, bitmap.height - 1),
-                                        face.boundingBox.width().coerceAtMost(bitmap.width - face.boundingBox.left),
-                                        face.boundingBox.height().coerceAtMost(bitmap.height - face.boundingBox.top)
-                                    )
 
                                     val embedding = faceNetModel.generateEmbedding(faceBitmap)
                                     faceBitmap.recycle()

app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppNavHost.kt

@@ -339,10 +339,7 @@ fun AppNavHost(
          * SETTINGS SCREEN
          */
         composable(AppRoutes.SETTINGS) {
-            DummyScreen(
+            com.placeholder.sherpai2.ui.settings.SettingsScreen()
-                title = "Settings",
-                subtitle = "App preferences and configuration"
-            )
         }
     }
 }

app/src/main/java/com/placeholder/sherpai2/ui/presentation/MainScreen.kt

@@ -78,6 +78,7 @@ fun MainScreen(
                                     AppRoutes.DISCOVER -> "Discover People"  // ✅ SHOWS NOW!
                                     AppRoutes.INVENTORY -> "People"
                                     AppRoutes.TRAIN -> "Train Model"
+                                    AppRoutes.ScanResultsScreen -> "Train New Person"
                                     AppRoutes.TAGS -> "Tags"
                                     AppRoutes.UTILITIES -> "Utilities"
                                     AppRoutes.SETTINGS -> "Settings"

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Facedetectionhelper.kt

@@ -6,8 +6,11 @@ import android.graphics.BitmapFactory
 import android.graphics.Rect
 import android.net.Uri
 import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.face.Face
 import com.google.mlkit.vision.face.FaceDetection
 import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.placeholder.sherpai2.domain.clustering.FaceQualityFilter
+import com.placeholder.sherpai2.ml.FaceNormalizer
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
@@ -64,21 +67,29 @@ class FaceDetectionHelper(private val context: Context) {
                 val inputImage = InputImage.fromBitmap(bitmap, 0)
                 val faces = detector.process(inputImage).await()
 
-                // Sort by face size (area) to get the largest face
+                // Filter to quality faces only
-                val sortedFaces = faces.sortedByDescending { face ->
+                val qualityFaces = faces.filter { face ->
+                    FaceQualityFilter.validateForDiscovery(
+                        face = face,
+                        imageWidth = bitmap.width,
+                        imageHeight = bitmap.height
+                    ).isValid
+                }
+
+                // Sort by face size (area) to get the largest quality face
+                val sortedFaces = qualityFaces.sortedByDescending { face ->
                     face.boundingBox.width() * face.boundingBox.height()
                 }
 
                 val croppedFace = if (sortedFaces.isNotEmpty()) {
-                    // Crop the LARGEST detected face (most likely the subject)
+                    FaceNormalizer.cropAndNormalize(bitmap, sortedFaces[0])
-                    cropFaceFromBitmap(bitmap, sortedFaces[0].boundingBox)
                 } else null
 
                 FaceDetectionResult(
                     uri = uri,
-                    hasFace = faces.isNotEmpty(),
+                    hasFace = qualityFaces.isNotEmpty(),
-                    faceCount = faces.size,
+                    faceCount = qualityFaces.size,
-                    faceBounds = faces.map { it.boundingBox },
+                    faceBounds = qualityFaces.map { it.boundingBox },
                     croppedFaceBitmap = croppedFace
                 )
             } catch (e: Exception) {

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/ScanResultsScreen.kt

@@ -51,21 +51,8 @@ fun ScanResultsScreen(
         }
     }
 
-    Scaffold(
+    // No Scaffold - MainScreen provides TopAppBar
-        topBar = {
+    Box(modifier = Modifier.fillMaxSize()) {
-            TopAppBar(
-                title = { Text("Train New Person") },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.primaryContainer
-                )
-            )
-        }
-    ) { paddingValues ->
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(paddingValues)
-        ) {
         when (state) {
             is ScanningState.Idle -> {}
 
@@ -77,8 +64,6 @@ fun ScanResultsScreen(
                 ImprovedResultsView(
                     result = state.sanityCheckResult,
                     onContinue = {
-                            // PersonInfo already captured in TrainingScreen!
-                            // Just start training with stored info
                         trainViewModel.createFaceModel(
                             trainViewModel.getPersonInfo()?.name ?: "Unknown"
                         )
@@ -103,7 +88,6 @@ fun ScanResultsScreen(
             TrainingOverlay(trainingState = trainingState as TrainingState.Processing)
         }
     }
-    }
 
     showFacePickerDialog?.let { result ->
         FacePickerDialog(

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/TrainViewModel.kt

@@ -5,11 +5,18 @@ import android.graphics.Bitmap
 import android.net.Uri
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.viewModelScope
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import androidx.work.WorkManager
+import android.content.Context
 import com.placeholder.sherpai2.data.local.entity.PersonEntity
 import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
 import com.placeholder.sherpai2.ml.FaceNetModel
+import com.placeholder.sherpai2.workers.LibraryScanWorker
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
@@ -48,15 +55,20 @@ data class PersonInfo(
 /**
  * FIXED TrainViewModel with proper exclude functionality and efficient replace
  */
+private val android.content.Context.dataStore by preferencesDataStore(name = "settings")
+private val KEY_BACKGROUND_TAGGING = booleanPreferencesKey("background_recognition_tagging")
+
 @HiltViewModel
 class TrainViewModel @Inject constructor(
     application: Application,
     private val faceRecognitionRepository: FaceRecognitionRepository,
-    private val faceNetModel: FaceNetModel
+    private val faceNetModel: FaceNetModel,
+    private val workManager: WorkManager
 ) : AndroidViewModel(application) {
 
     private val sanityChecker = TrainingSanityChecker(application)
     private val faceDetectionHelper = FaceDetectionHelper(application)
+    private val dataStore = application.dataStore
 
     private val _uiState = MutableStateFlow<ScanningState>(ScanningState.Idle)
     val uiState: StateFlow<ScanningState> = _uiState.asStateFlow()
@@ -174,6 +186,20 @@ class TrainViewModel @Inject constructor(
                     relationship = person.relationship
                 )
 
+                // Trigger library scan if setting enabled
+                val backgroundTaggingEnabled = dataStore.data
+                    .map { it[KEY_BACKGROUND_TAGGING] ?: true }
+                    .first()
+
+                if (backgroundTaggingEnabled) {
+                    val scanRequest = LibraryScanWorker.createWorkRequest(
+                        personId = personId,
+                        personName = personName,
+                        threshold = 0.65f
+                    )
+                    workManager.enqueue(scanRequest)
+                }
+
             } catch (e: Exception) {
                 _trainingState.value = TrainingState.Error(
                     e.message ?: "Failed to create face model"

app/src/main/java/com/placeholder/sherpai2/workers/Libraryscanworker.kt

@@ -9,6 +9,8 @@ import com.google.mlkit.vision.common.InputImage
 import com.google.mlkit.vision.face.FaceDetection
 import com.google.mlkit.vision.face.FaceDetectorOptions
 import com.placeholder.sherpai2.data.local.dao.FaceModelDao
+import com.placeholder.sherpai2.domain.clustering.FaceQualityFilter
+import com.placeholder.sherpai2.ml.FaceNormalizer
 import com.placeholder.sherpai2.data.local.dao.ImageDao
 import com.placeholder.sherpai2.data.local.dao.PhotoFaceTagDao
 import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
@@ -146,7 +148,12 @@ class LibraryScanWorker @AssistedInject constructor(
                     .build()
             )
 
-            val modelEmbedding = faceModel.getEmbeddingArray()
+            // Get ALL centroids for multi-centroid matching (critical for children)
+            val modelCentroids = faceModel.getCentroids().map { it.getEmbeddingArray() }
+            if (modelCentroids.isEmpty()) {
+                return@withContext Result.failure(workDataOf("error" to "No centroids in model"))
+            }
+
             var matchesFound = 0
             var photosScanned = 0
 
@@ -164,7 +171,7 @@ class LibraryScanWorker @AssistedInject constructor(
                                 photo = photo,
                                 personId = personId,
                                 faceModelId = faceModel.id,
-                                modelEmbedding = modelEmbedding,
+                                modelCentroids = modelCentroids,
                                 faceNetModel = faceNetModel,
                                 detector = detector,
                                 threshold = threshold
@@ -228,7 +235,7 @@ class LibraryScanWorker @AssistedInject constructor(
         photo: com.placeholder.sherpai2.data.local.entity.ImageEntity,
         personId: String,
         faceModelId: String,
-        modelEmbedding: FloatArray,
+        modelCentroids: List<FloatArray>,
         faceNetModel: FaceNetModel,
         detector: com.google.mlkit.vision.face.FaceDetector,
         threshold: Float
@@ -243,24 +250,26 @@ class LibraryScanWorker @AssistedInject constructor(
             val inputImage = InputImage.fromBitmap(bitmap, 0)
             val faces = detector.process(inputImage).await()
 
-            // Check each face
+            // Check each face (filter by quality first)
             val tags = faces.mapNotNull { face ->
+                // Quality check
+                if (!FaceQualityFilter.validateForScanning(face, bitmap.width, bitmap.height)) {
+                    return@mapNotNull null
+                }
+
                 try {
-                    // Crop face
+                    // Crop and normalize face for best recognition
-                    val faceBitmap = android.graphics.Bitmap.createBitmap(
+                    val faceBitmap = FaceNormalizer.cropAndNormalize(bitmap, face)
-                        bitmap,
+                        ?: return@mapNotNull null
-                        face.boundingBox.left.coerceIn(0, bitmap.width - 1),
-                        face.boundingBox.top.coerceIn(0, bitmap.height - 1),
-                        face.boundingBox.width().coerceAtMost(bitmap.width - face.boundingBox.left),
-                        face.boundingBox.height().coerceAtMost(bitmap.height - face.boundingBox.top)
-                    )
 
                     // Generate embedding
                     val faceEmbedding = faceNetModel.generateEmbedding(faceBitmap)
                     faceBitmap.recycle()
 
-                    // Calculate similarity
+                    // Match against ALL centroids, use best match (critical for children)
-                    val similarity = faceNetModel.calculateSimilarity(faceEmbedding, modelEmbedding)
+                    val similarity = modelCentroids.maxOfOrNull { centroid ->
+                        faceNetModel.calculateSimilarity(faceEmbedding, centroid)
+                    } ?: 0f
 
                     if (similarity >= threshold) {
                         PhotoFaceTagEntity.create(