birdnet-analyzer 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

birdnet_analyzer/embeddings/core.py

@@ -8,6 +8,7 @@ def embeddings(
     fmax: int = 15000,
     threads: int = 8,
     batch_size: int = 1,
+    file_output: str | None = None,
 ):
     """
     Generates embeddings for audio files using the BirdNET-Analyzer.
@@ -46,7 +47,7 @@ def embeddings(
     from birdnet_analyzer.utils import ensure_model_exists
 
     ensure_model_exists()
-    run(audio_input, database, overlap, audio_speed, fmin, fmax, threads, batch_size)
+    run(audio_input, database, overlap, audio_speed, fmin, fmax, threads, batch_size, file_output)
 
 
 def get_database(db_path: str):

birdnet_analyzer/embeddings/utils.py

@@ -25,6 +25,7 @@ def analyze_file(item, db: sqlite_usearch_impl.SQLiteUsearchDB):
     Args:
         item: (filepath, config)
     """
+
     # Get file path and restore cfg
     fpath: str = item[0]
     cfg.set_config(item[1])
@@ -124,7 +125,44 @@ def check_database_settings(db: sqlite_usearch_impl.SQLiteUsearchDB):
         db.commit()
 
 
-def run(audio_input, database, overlap, audio_speed, fmin, fmax, threads, batchsize):
+def create_file_output(output_path: str, db: sqlite_usearch_impl.SQLiteUsearchDB):
+    """Creates a file output for the database.
+
+    Args:
+        output_path: Path to the output file.
+        db: Database object.
+    """
+    # Check if output path exists
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+    # Get all embeddings
+    embedding_ids = db.get_embedding_ids()
+
+    # Write embeddings to file
+    for embedding_id in embedding_ids:
+        embedding = db.get_embedding(embedding_id)
+        source = db.get_embedding_source(embedding_id)
+
+        # Get start and end time
+        start, end = source.offsets
+
+        source_id = source.source_id.rsplit(".", 1)[0]
+
+        filename = f"{source_id}_{start}_{end}.birdnet.embeddings.txt"
+
+        # Get the common prefix between the output path and the filename
+        common_prefix = os.path.commonpath([output_path, os.path.dirname(filename)])
+        relative_filename = os.path.relpath(filename, common_prefix)
+        target_path = os.path.join(output_path, relative_filename)
+
+        # Ensure the target directory exists
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+
+        # Write embedding values to a text file
+        with open(target_path, "w") as f:
+            f.write(",".join(map(str, embedding.tolist())))
+
+def run(audio_input, database, overlap, audio_speed, fmin, fmax, threads, batchsize, file_output):
     ### Make sure to comment out appropriately if you are not using args. ###
 
     # Set input and output path
@@ -176,4 +214,7 @@ def run(audio_input, database, overlap, audio_speed, fmin, fmax, threads, batchs
         with Pool(cfg.CPU_THREADS) as p:
             tqdm(p.imap(partial(analyze_file, db=db), flist))
 
+    if file_output:
+        create_file_output(file_output, db)
+
     db.db.close()

birdnet_analyzer/evaluation/__init__.py

@@ -9,6 +9,7 @@ for columns, class mappings, and filtering based on selected classes or recordin
 import argparse
 import json
 import os
+from collections.abc import Sequence
 
 from birdnet_analyzer.evaluation.assessment.performance_assessor import (
     PerformanceAssessor,
@@ -25,7 +26,7 @@ def process_data(
     recording_duration: float | None = None,
     columns_annotations: dict[str, str] | None = None,
     columns_predictions: dict[str, str] | None = None,
-    selected_classes: list[str] | None = None,
+    selected_classes: Sequence[str] | None = None,
     selected_recordings: list[str] | None = None,
     metrics_list: tuple[str, ...] = ("accuracy", "precision", "recall"),
     threshold: float = 0.1,
@@ -61,14 +62,10 @@ def process_data(
 
     # Determine directory and file paths for annotations and predictions
     annotation_dir, annotation_file = (
-        (os.path.dirname(annotation_path), os.path.basename(annotation_path))
-        if os.path.isfile(annotation_path)
-        else (annotation_path, None)
+        (os.path.dirname(annotation_path), os.path.basename(annotation_path)) if os.path.isfile(annotation_path) else (annotation_path, None)
     )
     prediction_dir, prediction_file = (
-        (os.path.dirname(prediction_path), os.path.basename(prediction_path))
-        if os.path.isfile(prediction_path)
-        else (prediction_path, None)
+        (os.path.dirname(prediction_path), os.path.basename(prediction_path)) if os.path.isfile(prediction_path) else (prediction_path, None)
     )
 
     # Initialize the DataProcessor to handle and prepare data
@@ -120,6 +117,8 @@ def main():
     """
     Entry point for the script. Parses command-line arguments and orchestrates the performance assessment pipeline.
     """
+    import matplotlib.pyplot as plt
+
     # Set up argument parsing
     parser = argparse.ArgumentParser(description="Performance Assessor Core Script")
     parser.add_argument("--annotation_path", required=True, help="Path to annotation file or folder")
@@ -171,8 +170,6 @@ def main():
     if args.plot_metrics:
         pa.plot_metrics(predictions, labels, per_class_metrics=args.class_wise)
         if args.output_dir:
-            import matplotlib.pyplot as plt
-
             plt.savefig(os.path.join(args.output_dir, "metrics_plot.png"))
         else:
             plt.show()
@@ -180,8 +177,6 @@ def main():
     if args.plot_confusion_matrix:
         pa.plot_confusion_matrix(predictions, labels)
         if args.output_dir:
-            import matplotlib.pyplot as plt
-
             plt.savefig(os.path.join(args.output_dir, "confusion_matrix.png"))
         else:
             plt.show()
@@ -189,8 +184,6 @@ def main():
     if args.plot_metrics_all_thresholds:
         pa.plot_metrics_all_thresholds(predictions, labels, per_class_metrics=args.class_wise)
         if args.output_dir:
-            import matplotlib.pyplot as plt
-
             plt.savefig(os.path.join(args.output_dir, "metrics_all_thresholds.png"))
         else:
             plt.show()

birdnet_analyzer/evaluation/assessment/performance_assessor.py

@@ -8,10 +8,9 @@ as well as utilities for generating related plots.
 
 from typing import Literal
 
-import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix
+from sklearn.metrics import confusion_matrix
 
 from birdnet_analyzer.evaluation.assessment import metrics, plotting
 
@@ -121,10 +120,7 @@ class PerformanceAssessor:
         if predictions.ndim != 2:
             raise ValueError("predictions and labels must be 2-dimensional arrays.")
         if predictions.shape[1] != self.num_classes:
-            raise ValueError(
-                f"The number of columns in predictions ({predictions.shape[1]}) "
-                + f"must match num_classes ({self.num_classes})."
-            )
+            raise ValueError(f"The number of columns in predictions ({predictions.shape[1]}) " + f"must match num_classes ({self.num_classes}).")
 
         # Determine the averaging method for metrics
         if per_class_metrics and self.num_classes == 1:
@@ -192,11 +188,7 @@ class PerformanceAssessor:
                 metrics_results["Accuracy"] = np.atleast_1d(result)
 
         # Define column names for the DataFrame
-        columns = (
-            (self.classes if self.classes else [f"Class {i}" for i in range(self.num_classes)])
-            if per_class_metrics
-            else ["Overall"]
-        )
+        columns = (self.classes if self.classes else [f"Class {i}" for i in range(self.num_classes)]) if per_class_metrics else ["Overall"]
 
         # Create a DataFrame to organize metric results
         metrics_data = {key: np.atleast_1d(value) for key, value in metrics_results.items()}
@@ -207,7 +199,7 @@ class PerformanceAssessor:
         predictions: np.ndarray,
         labels: np.ndarray,
         per_class_metrics: bool = False,
-    ) -> None:
+    ):
         """
         Plot performance metrics for the given predictions and labels.
 
@@ -226,18 +218,14 @@ class PerformanceAssessor:
         metrics_df = self.calculate_metrics(predictions, labels, per_class_metrics)
 
         # Choose the plotting method based on whether per-class metrics are required
-        return (
-            plotting.plot_metrics_per_class(metrics_df, self.colors)
-            if per_class_metrics
-            else plotting.plot_overall_metrics(metrics_df, self.colors)
-        )
+        return plotting.plot_metrics_per_class(metrics_df, self.colors) if per_class_metrics else plotting.plot_overall_metrics(metrics_df, self.colors)
 
     def plot_metrics_all_thresholds(
         self,
         predictions: np.ndarray,
         labels: np.ndarray,
         per_class_metrics: bool = False,
-    ) -> None:
+    ):
         """
         Plot performance metrics across thresholds for the given predictions and labels.
 
@@ -266,9 +254,7 @@ class PerformanceAssessor:
             class_names = list(self.classes) if self.classes else [f"Class {i}" for i in range(self.num_classes)]
 
             # Initialize a dictionary to store metric values per class
-            metric_values_dict_per_class = {
-                class_name: {metric: [] for metric in metrics_to_plot} for class_name in class_names
-            }
+            metric_values_dict_per_class = {class_name: {metric: [] for metric in metrics_to_plot} for class_name in class_names}
 
             # Compute metrics for each threshold
             for thresh in thresholds:
@@ -321,7 +307,7 @@ class PerformanceAssessor:
         self,
         predictions: np.ndarray,
         labels: np.ndarray,
-    ) -> None:
+    ):
         """
         Plot confusion matrices for each class using scikit-learn's ConfusionMatrixDisplay.
 
@@ -346,10 +332,7 @@ class PerformanceAssessor:
         if predictions.ndim != 2:
             raise ValueError("predictions and labels must be 2-dimensional arrays.")
         if predictions.shape[1] != self.num_classes:
-            raise ValueError(
-                f"The number of columns in predictions ({predictions.shape[1]}) "
-                + f"must match num_classes ({self.num_classes})."
-            )
+            raise ValueError(f"The number of columns in predictions ({predictions.shape[1]}) " + f"must match num_classes ({self.num_classes}).")
 
         if self.task == "binary":
             # Binarize predictions using the threshold
@@ -360,13 +343,7 @@ class PerformanceAssessor:
             conf_mat = confusion_matrix(y_true, y_pred, normalize="true")
             conf_mat = np.round(conf_mat, 2)
 
-            # Plot the confusion matrix
-            disp = ConfusionMatrixDisplay(confusion_matrix=conf_mat, display_labels=["Negative", "Positive"])
-            fig, ax = plt.subplots(figsize=(6, 6))
-            disp.plot(cmap="Reds", ax=ax, colorbar=False, values_format=".2f")
-            ax.set_title("Confusion Matrix")
-
-            return fig
+            return plotting.plot_confusion_matrices(conf_mat, self.task, self.classes)
 
         if self.task == "multilabel":
             # Binarize predictions for multilabel classification
@@ -376,34 +353,12 @@ class PerformanceAssessor:
             # Compute confusion matrices for each class
             conf_mats = []
             class_names = self.classes if self.classes else [f"Class {i}" for i in range(self.num_classes)]
+
             for i in range(self.num_classes):
                 conf_mat = confusion_matrix(y_true[:, i], y_pred[:, i], normalize="true")
                 conf_mat = np.round(conf_mat, 2)
                 conf_mats.append(conf_mat)
 
-            # Determine grid size for subplots
-            num_matrices = self.num_classes
-            n_cols = int(np.ceil(np.sqrt(num_matrices)))
-            n_rows = int(np.ceil(num_matrices / n_cols))
-
-            # Create subplots for each confusion matrix
-            fig, axes = plt.subplots(n_rows, n_cols, figsize=(4 * n_cols, 4 * n_rows))
-            axes = axes.flatten()
-
-            # Plot each confusion matrix
-            for idx, (conf_mat, class_name) in enumerate(zip(conf_mats, class_names, strict=True)):
-                disp = ConfusionMatrixDisplay(confusion_matrix=conf_mat, display_labels=["Negative", "Positive"])
-                disp.plot(cmap="Reds", ax=axes[idx], colorbar=False, values_format=".2f")
-                axes[idx].set_title(f"{class_name}")
-                axes[idx].set_xlabel("Predicted class")
-                axes[idx].set_ylabel("True class")
-
-            # Remove unused subplot axes
-            for ax in axes[num_matrices:]:
-                fig.delaxes(ax)
-
-            plt.tight_layout()
-
-            return fig
+            return plotting.plot_confusion_matrices(np.array(conf_mats), self.task, class_names)
 
         raise ValueError(f"Unsupported task type: {self.task}")

birdnet_analyzer/evaluation/assessment/plotting.py

@@ -18,10 +18,17 @@ from typing import Literal
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import seaborn as sns
+from sklearn.metrics import ConfusionMatrixDisplay
 
+MATPLOTLIB_BINARY_CONFUSION_MATRIX_FIGURE_NUM = "performance-tab-binary-confusion-matrix-plot"
+MATPLOTLIB_MULTICLASS_CONFUSION_MATRIX_FIGURE_NUM = "performance-tab-multiclass-confusion-matrix-plot"
+MATPLOTLIB_OVERALL_METRICS_FIGURE_NUM = "performance-tab-overall-metrics-plot"
+MATPLOTLIB_PER_CLASS_METRICS_FIGURE_NUM = "performance-tab-per-class-metrics-plot"
+MATPLOTLIB_ACROSS_METRICS_THRESHOLDS_FIGURE_NUM = "performance-tab-metrics-across-thresholds-plot"
+MATPLOTLIB_ACROSS_METRICS_THRESHOLDS_PER_CLASS_FIGURE_NUM = "performance-tab-metrics-across-thresholds-per-class-plot"
 
-def plot_overall_metrics(metrics_df: pd.DataFrame, colors: list[str]) -> plt.Figure:
+
+def plot_overall_metrics(metrics_df: pd.DataFrame, colors: list[str]):
     """
     Plots a bar chart for overall performance metrics.
 
@@ -55,7 +62,11 @@ def plot_overall_metrics(metrics_df: pd.DataFrame, colors: list[str]) -> plt.Fig
     values = metrics_df["Overall"].to_numpy()  # Metric values
 
     # Plot bar chart
-    fig = plt.figure(figsize=(10, 6))
+    fig = plt.figure(MATPLOTLIB_OVERALL_METRICS_FIGURE_NUM, figsize=(10, 6))
+    fig.clear()
+    fig.tight_layout(pad=0)
+    fig.set_dpi(300)
+
     plt.bar(metrics, values, color=colors[: len(metrics)])
 
     # Add titles, labels, and format
@@ -64,12 +75,11 @@ def plot_overall_metrics(metrics_df: pd.DataFrame, colors: list[str]) -> plt.Fig
     plt.ylabel("Score", fontsize=12)
     plt.xticks(rotation=45, ha="right", fontsize=10)
     plt.grid(axis="y", linestyle="--", alpha=0.7)
-    plt.tight_layout()
 
     return fig
 
 
-def plot_metrics_per_class(metrics_df: pd.DataFrame, colors: list[str]) -> plt.Figure:
+def plot_metrics_per_class(metrics_df: pd.DataFrame, colors: list[str]):
     """
     Plots metric values per class, with each metric represented by a distinct color and line.
 
@@ -97,7 +107,10 @@ def plot_metrics_per_class(metrics_df: pd.DataFrame, colors: list[str]) -> plt.F
 
     # Line styles for distinction
     line_styles = ["-", "--", "-.", ":", (0, (5, 10)), (0, (5, 5)), (0, (3, 5, 1, 5))]
-    fig = plt.figure(figsize=(10, 6))
+    fig = plt.figure(MATPLOTLIB_OVERALL_METRICS_FIGURE_NUM, figsize=(10, 6))
+    fig.clear()
+    fig.tight_layout(pad=0)
+    fig.set_dpi(300)
 
     # Loop over each metric and plot it
     for i, metric_name in enumerate(metrics_df.index):
@@ -120,7 +133,6 @@ def plot_metrics_per_class(metrics_df: pd.DataFrame, colors: list[str]) -> plt.F
     plt.ylabel("Score", fontsize=12)
     plt.legend(loc="lower right")
     plt.grid(True)
-    plt.tight_layout()
 
     return fig
 
@@ -130,7 +142,7 @@ def plot_metrics_across_thresholds(
     metric_values_dict: dict[str, np.ndarray],
     metrics_to_plot: list[str],
     colors: list[str],
-) -> plt.Figure:
+):
     """
     Plots metrics across different thresholds.
 
@@ -164,7 +176,10 @@ def plot_metrics_across_thresholds(
 
     # Line styles for distinction
     line_styles = ["-", "--", "-.", ":", (0, (5, 10)), (0, (5, 5)), (0, (3, 5, 1, 5))]
-    fig = plt.figure(figsize=(10, 6))
+    fig = plt.figure(MATPLOTLIB_ACROSS_METRICS_THRESHOLDS_FIGURE_NUM, figsize=(10, 6))
+    fig.clear()
+    fig.tight_layout(pad=0)
+    fig.set_dpi(300)
 
     # Plot each metric against thresholds
     for i, metric_name in enumerate(metrics_to_plot):
@@ -188,7 +203,6 @@ def plot_metrics_across_thresholds(
     plt.ylabel("Metric Score", fontsize=12)
     plt.legend(loc="best")
     plt.grid(True)
-    plt.tight_layout()
 
     return fig
 
@@ -199,7 +213,7 @@ def plot_metrics_across_thresholds_per_class(
     metrics_to_plot: list[str],
     class_names: list[str],
     colors: list[str],
-) -> plt.Figure:
+):
     """
     Plots metrics across different thresholds per class.
 
@@ -244,7 +258,10 @@ def plot_metrics_across_thresholds_per_class(
     n_rows = int(np.ceil(num_classes / n_cols))
 
     # Create subplots
-    fig, axes = plt.subplots(n_rows, n_cols, figsize=(n_cols * 5, n_rows * 4))
+    fig, axes = plt.subplots(n_rows, n_cols, figsize=(n_cols * 5, n_rows * 4), num=MATPLOTLIB_ACROSS_METRICS_THRESHOLDS_PER_CLASS_FIGURE_NUM)
+    fig.clear()
+    fig.tight_layout(pad=0)
+    fig.set_dpi(300)
 
     # Flatten axes for easy indexing
     axes = [axes] if num_classes == 1 else axes.flatten()
@@ -265,10 +282,7 @@ def plot_metrics_across_thresholds_per_class(
                 raise KeyError(f"Metric '{metric_name}' not found for class '{class_name}'.")
             metric_values = metric_values_dict[metric_name]
             if len(metric_values) != len(thresholds):
-                raise ValueError(
-                    f"Length of metric '{metric_name}' values for class '{class_name}' "
-                    + "does not match length of thresholds."
-                )
+                raise ValueError(f"Length of metric '{metric_name}' values for class '{class_name}' " + "does not match length of thresholds.")
             ax.plot(
                 thresholds,
                 metric_values,
@@ -285,13 +299,6 @@ def plot_metrics_across_thresholds_per_class(
         ax.legend(loc="best", fontsize=8)
         ax.grid(True)
 
-    # Hide any unused subplots
-    for j in range(num_classes, len(axes)):
-        fig.delaxes(axes[j])
-
-    # Adjust layout and show
-    plt.tight_layout()
-
     return fig
 
 
@@ -299,7 +306,7 @@ def plot_confusion_matrices(
     conf_mat: np.ndarray,
     task: Literal["binary", "multiclass", "multilabel"],
     class_names: list[str],
-) -> plt.Figure:
+):
     """
     Plots confusion matrices for each class in a single figure with multiple subplots.
 
@@ -323,57 +330,49 @@ def plot_confusion_matrices(
         raise ValueError("conf_mat is empty.")
     if not isinstance(task, str) or task not in ["binary", "multiclass", "multilabel"]:
         raise ValueError("Invalid task. Expected 'binary', 'multiclass', or 'multilabel'.")
-    if not isinstance(class_names, list):
-        raise TypeError("class_names must be a list.")
-    if len(class_names) == 0:
-        raise ValueError("class_names list is empty.")
 
     if task == "binary":
         # Binary classification expects a single 2x2 matrix
         if conf_mat.shape != (2, 2):
             raise ValueError("For binary task, conf_mat must be of shape (2, 2).")
-        if len(class_names) != 2:
-            raise ValueError("For binary task, class_names must have exactly two elements.")
-
-        # Plot single confusion matrix
-        fig = plt.figure(figsize=(4, 4))
-        sns.heatmap(conf_mat, annot=True, fmt=".2f", cmap="Reds", cbar=False)
-        plt.title("Confusion Matrix")
-        plt.xlabel("Predicted Class")
-        plt.ylabel("True Class")
-        plt.tight_layout()
+
+        disp = ConfusionMatrixDisplay(confusion_matrix=conf_mat, display_labels=["Negative", "Positive"])
+        fig, ax = plt.subplots(num=MATPLOTLIB_BINARY_CONFUSION_MATRIX_FIGURE_NUM, figsize=(6, 6))
+
+        fig.tight_layout()
+        fig.set_dpi(300)
+        disp.plot(cmap="Reds", ax=ax, colorbar=False, values_format=".2f")
+        ax.set_title("Confusion Matrix")
     else:
         # Multilabel or multiclass expects a set of 2x2 matrices
-        num_labels = conf_mat.shape[0]
+        num_matrices = conf_mat.shape[0]
+
         if conf_mat.shape[1:] != (2, 2):
             raise ValueError("For multilabel or multiclass task, conf_mat must have shape (num_labels, 2, 2).")
-        if len(class_names) != num_labels:
+        if len(class_names) != num_matrices:
             raise ValueError("Length of class_names must match number of labels in conf_mat.")
 
         # Determine grid size for subplots
-        n_cols = int(np.ceil(np.sqrt(num_labels)))
-        n_rows = int(np.ceil(num_labels / n_cols))
-
-        # Create subplots
-        fig, axes = plt.subplots(n_rows, n_cols, figsize=(n_cols * 2, n_rows * 2))
-
-        # Flatten axes for easy indexing
-        axes = [axes] if num_labels == 1 else axes.flatten()
-
-        # Plot each class's confusion matrix
-        for i in range(num_labels):
-            cm = conf_mat[i]
-            ax = axes[i]
-            sns.heatmap(cm, annot=True, fmt=".2f", cmap="Reds", cbar=False, ax=ax)
-            ax.set_title(f"{class_names[i]}")
-            ax.set_xlabel("Predicted Class")
-            ax.set_ylabel("True Class")
-
-        # Hide any unused subplots
-        for j in range(num_labels, len(axes)):
-            fig.delaxes(axes[j])
+        n_cols = int(np.ceil(np.sqrt(num_matrices)))
+        n_rows = int(np.ceil(num_matrices / n_cols))
+
+        # Create subplots for each confusion matrix
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=(4 * n_cols, 4 * n_rows), num=MATPLOTLIB_MULTICLASS_CONFUSION_MATRIX_FIGURE_NUM)
+        fig.set_dpi(300)
+        axes = axes.flatten() if hasattr(axes, "flatten") else [axes]
+
+        # Plot each confusion matrix
+        for idx, (cf, class_name) in enumerate(zip(conf_mat, class_names, strict=True)):
+            disp = ConfusionMatrixDisplay(confusion_matrix=cf, display_labels=["Negative", "Positive"])
+            disp.plot(cmap="Reds", ax=axes[idx], colorbar=False, values_format=".2f")
+            axes[idx].set_title(f"{class_name}")
+            axes[idx].set_xlabel("Predicted class")
+            axes[idx].set_ylabel("True class")
+
+        # Remove unused subplot axes
+        for ax in axes[num_matrices:]:
+            fig.delaxes(ax)
 
-        # Adjust layout and show
         plt.tight_layout()
 
     return fig

birdnet_analyzer/evaluation/preprocessing/data_processor.py

@@ -565,7 +565,7 @@ class DataProcessor:
         self,
         selected_classes: list[str] | None = None,
         selected_recordings: list[str] | None = None,
-    ) -> tuple[np.ndarray, np.ndarray, tuple[str]]:
+    ) -> tuple[np.ndarray, np.ndarray, tuple[str, ...]]:
         """
         Filters the prediction and label tensors based on selected classes and recordings.
 

birdnet_analyzer/gui/analysis.py

@@ -5,7 +5,6 @@ from pathlib import Path
 import gradio as gr
 
 import birdnet_analyzer.config as cfg
-import birdnet_analyzer.gui.localization as loc
 import birdnet_analyzer.gui.utils as gu
 from birdnet_analyzer import model
 from birdnet_analyzer.analyze.utils import (
@@ -55,6 +54,7 @@ def run_analysis(
     sf_thresh: float,
     custom_classifier_file,
     output_types: str,
+    additional_columns: list[str] | None,
     combine_tables: bool,
     locale: str,
     batch_size: int,
@@ -85,6 +85,7 @@ def run_analysis(
         sf_thresh: The threshold for the predicted species list.
         custom_classifier_file: Custom classifier to be used.
         output_type: The type of result to be generated.
+        additional_columns: Additional columns to be added to the result.
         output_filename: The filename for the combined output.
         locale: The translation to be used.
         batch_size: The number of samples in a batch.
@@ -92,6 +93,8 @@ def run_analysis(
         input_dir: The input directory.
         progress: The gradio progress bar.
     """
+    import birdnet_analyzer.gui.localization as loc
+
     if progress is not None:
         progress(0, desc=f"{loc.localize('progress-preparing')} ...")
 
@@ -128,6 +131,7 @@ def run_analysis(
         slist=slist,
         top_n=top_n if use_top_n else None,
         output=output_path,
+        additional_columns=additional_columns,
     )
 
     if species_list_choice == gu._CUSTOM_CLASSIFIER:

birdnet_analyzer/gui/assets/gui.css

@@ -26,4 +26,12 @@ footer {
     overflow: auto;
     flex-wrap: nowrap;
     padding-right: 5px;
+}
+
+#heart {
+    display: inline;
+    background-color: white;
+    border-radius: 3px;
+    margin-right: 3px;
+    padding: 1px;
 }