client side active learning updates

Author: Abe404

painter/src/main/python/nav.py

@@ -71,21 +71,127 @@ def get_path_list(self, dir_path):
                      for a in all_files]
         return all_paths
 
+
+    def select_highest_entropy_image(self):
+        """
+        Return filename of active image with highest entropy among
+        active images *after* the current image, or None if unavailable.
+        """
+        active_images_path = os.path.join(self.parent.proj_location, "active_images.txt")
+        uncertainty_dir = os.path.join(self.parent.proj_location, "uncertainty")
+
+        if not (os.path.isfile(active_images_path) and os.path.isdir(uncertainty_dir)):
+            return None
+
+        # Get active images set
+        with open(active_images_path, "r") as f:
+            active_images = {line.strip() for line in f if line.strip()}
+
+        # Determine current image position
+        current_fname = os.path.basename(self.image_path)
+        try:
+            current_idx = self.all_fnames.index(current_fname)
+        except ValueError:
+            return None  # safety fallback
+
+        # Only consider images after current
+        future_images = set(self.all_fnames[current_idx+1:])
+        candidate_images = active_images.intersection(future_images)
+
+        # Gather entropy scores for candidates
+        entropy_scores = {}
+        for fname in candidate_images:
+            score_file = os.path.join(uncertainty_dir, fname + ".txt")
+            if os.path.isfile(score_file):
+                try:
+                    with open(score_file, "r") as f_score:
+                        entropy = float(f_score.read().strip())
+                        entropy_scores[fname] = entropy
+                except Exception:
+                    continue
+
+        if not entropy_scores:
+            return None
+
+        return max(entropy_scores, key=entropy_scores.get)
+
+
+    def prefill_next_active_image(self):
+        """
+        Check if next even-index image (after current) is active and replace with highest entropy image.
+        """
+        current_idx = self.all_fnames.index(os.path.basename(self.image_path))
+        next_idx = current_idx + 1
+        if next_idx >= len(self.all_fnames):
+            return  # no next image
+
+        # Check if next image is in active list
+        active_images_path = os.path.join(self.parent.proj_location, "active_images.txt")
+        if not os.path.isfile(active_images_path):
+            return
+
+        with open(active_images_path, "r") as f:
+            active_images = {line.strip() for line in f if line.strip()}
+
+        next_image_name = self.all_fnames[next_idx]
+        if next_image_name not in active_images:
+            return  # next image is not active → no replacement
+
+        # Select best future active image
+        next_entropy_fname = self.select_highest_entropy_image()
+        if not next_entropy_fname:
+            return
+
+        # Replace only if different
+        if self.all_fnames[next_idx] != next_entropy_fname:
+            print(f"Prefill active: replacing {self.all_fnames[next_idx]} → {next_entropy_fname}")
+            self.all_fnames[next_idx] = next_entropy_fname
+
+            # Save updated list to project file
+            import json
+            project_file = self.parent.proj_file_path
+            with open(project_file, 'r') as f:
+                project_data = json.load(f)
+            project_data['file_names'] = self.all_fnames
+            with open(project_file, 'w') as f:
+                json.dump(project_data, f, indent=4)
+
+
     def show_next_image(self):
         self.next_image_button.setEnabled(False)
         self.next_image_button.setText('Loading..')
-        self.next_image_button.setEnabled(False)
         QtWidgets.QApplication.processEvents()
+
+        # normal next
         dir_path, _ = os.path.split(self.image_path)
         all_paths = self.get_path_list(dir_path)
         cur_idx = all_paths.index(self.image_path)
-        next_idx = cur_idx + 1
-        if next_idx >= len(all_paths):
-            next_idx = 0
-        self.image_path = all_paths[next_idx]
+        next_idx = (cur_idx + 1) % len(all_paths)
+        next_fname = os.path.basename(all_paths[next_idx])
+
+        # if next image is active, use highest entropy image instead
+        next_entropy_fname = None
+        active_images_path = os.path.join(self.parent.proj_location, "active_images.txt")
+        if os.path.isfile(active_images_path):
+            with open(active_images_path, "r") as f:
+                active_images = {line.strip() for line in f if line.strip()}
+            if next_fname in active_images:
+                next_entropy_fname = self.select_highest_entropy_image()
+
+        if next_entropy_fname:
+            next_image_path = os.path.join(dir_path, next_entropy_fname)
+        else:
+            next_image_path = all_paths[next_idx]
+
+        # update current image
+        self.image_path = next_image_path
         self.file_change.emit(self.image_path)
         self.update_nav_label()
 
+        # prefill future active slot
+        self.prefill_next_active_image()
+
+
     def show_prev_image(self):
         dir_path, _ = os.path.split(self.image_path)
         all_paths = self.get_path_list(dir_path)

painter/src/main/python/root_painter.py

@@ -74,6 +74,17 @@
 Image.MAX_IMAGE_PIXELS = None
 
 
+def generate_active_images_file(project_dir, image_fnames, step=2, skip=6):
+    active_list = image_fnames[skip::step]  # skip first N, then every 2nd image
+    active_file = os.path.join(project_dir, "active_images.txt")
+    with open(active_file, "w") as f:
+        for name in active_list:
+            f.write(f"{name}\n")
+    print(f"[RootPainter] Wrote {len(active_list)} active images to {active_file}")
+    return len(active_list)
+
+
+
 class RootPainter(QtWidgets.QMainWindow):
 
     closed = QtCore.pyqtSignal()
@@ -686,12 +697,34 @@ def update_dataset_after_check():
                     self.nav.update_nav_label()
             extend_dataset_btn.triggered.connect(update_dataset_after_check)
             extras_menu.addAction(extend_dataset_btn)
-          
 
 
-        
+            generate_active_btn = QtWidgets.QAction(QtGui.QIcon('missing.png'),
+                                                    'Generate active image list',
+                                                    self)
+            def call_generate_active():
+                # Only works if project is open
+                if hasattr(self, 'proj_location') and hasattr(self, 'image_fnames'):
+                    active_file = os.path.join(self.proj_location, "active_images.txt")
+                    if os.path.isfile(active_file):
+                        reply = QtWidgets.QMessageBox.question(
+                            self, 'File exists',
+                            "active_images.txt already exists.\nDo you want to overwrite it?",
+                            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
+                            QtWidgets.QMessageBox.No)
+                        if reply == QtWidgets.QMessageBox.No:
+                            return  # do nothing
+
+                    count = generate_active_images_file(self.proj_location, self.image_fnames)
+                    QtWidgets.QMessageBox.information(self, "Active list generated", 
+                        f"active_images.txt created with {count} active images.")
+                else:
+                    QtWidgets.QMessageBox.warning(self, "Error", 
+                        "No project open. Open a project first.")
+
+            generate_active_btn.triggered.connect(call_generate_active)
+            extras_menu.addAction(generate_active_btn)
 
-    
 
     def add_about_menu(self, menu_bar):
         about_menu = menu_bar.addMenu('About')