feat:_ add settings to enable thumbnails on dashboard

assets/custom.css

@@ -19,6 +19,29 @@
     box-shadow: 0 0 0 2px rgba(164, 202, 254, 0.45);
 }
 
+.thumbnail-container {
+  position: relative;
+  display: inline-block;
+}
+
+.thumbnail-tooltip {
+  position: absolute;
+  bottom: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+  background-color: rgba(0, 0, 0, 0.8);
+  color: white;
+  padding: 5px 10px;
+  border-radius: 4px;
+  font-size: 12px;
+  white-space: nowrap;
+  z-index: 10;
+}
+
+.thumbnail-container:hover .thumbnail-tooltip {
+  display: block;
+}
+
   /* Define your custom background colors here if the default Tailwind classes aren't working */
   .bg-confidence-high { background-color: #10b981; } /* Green for high confidence */
   .bg-confidence-medium { background-color: #f97316; } /* Orange for average confidence */

internal/analysis/realtime.go

@@ -110,8 +110,13 @@ func RealtimeAnalysis(settings *conf.Settings) error {
 		log.Fatalf("Error initializing metrics: %v", err)
 	}
 
-	// Intialize bird image cache
-	birdImageCache := initBirdImageCache(dataStore, metrics)
+	var birdImageCache *imageprovider.BirdImageCache
+	if settings.Realtime.Dashboard.Thumbnails.Summary || settings.Realtime.Dashboard.Thumbnails.Recent {
+		// Initialize the bird image cache
+		birdImageCache = initBirdImageCache(dataStore, metrics)
+	} else {
+		birdImageCache = nil
+	}
 
 	// Start worker pool for processing detections
 	processor.New(settings, dataStore, bn, metrics, birdImageCache)

internal/conf/config.go

@@ -1,4 +1,4 @@
-// conf/config.go
+// config.go: This file contains the configuration for the BirdNET-Go application. It defines the settings struct and functions to load and save the settings.
 package conf
 
 import (
@@ -17,11 +17,18 @@ import (
 //go:embed config.yaml
 var configFiles embed.FS
 
+type Dashboard struct {
+	Thumbnails struct {
+		Summary bool // show thumbnails on summary table
+		Recent  bool // show thumbnails on recent table
+	}
+}
+
 type Settings struct {
 	Debug bool // true to enable debug mode
 
 	Main struct {
-		Name      string // name of go-birdnet node, can be used to identify source of notes
+		Name      string // name of BirdNET-Go node, can be used to identify source of notes
 		TimeAs24h bool   // true 24-hour time format, false 12-hour time format
 		Log       LogConfig
 	}
@@ -66,6 +73,9 @@ type Settings struct {
 			}
 		}
 
+		// Apply dashboard settings
+		Dashboard Dashboard
+
 		DynamicThreshold struct {
 			Enabled    bool    // true to enable dynamic threshold
 			Debug      bool    // true to enable debug mode

internal/conf/config.yaml

@@ -44,6 +44,11 @@ realtime:
         maxusage: 80%     # usage policy: percentage of disk usage to trigger eviction        
         minclips: 10      # minumum number of clips per species to keep before starting evictions
 
+  dashboard:
+    thumbnails:
+      summary: false
+      recent: true
+
   dynamicthreshold:
     enabled: true         # true to enable dynamic confidence threshold
     trigger: 0.90         # dynamic threshold is activated on detections at this confidence level

internal/conf/defaults.go

@@ -44,6 +44,10 @@ func setDefaultConfig() {
 	viper.SetDefault("realtime.audio.export.path", "clips/")
 	viper.SetDefault("realtime.audio.export.type", "wav")
 
+	// Dashboard thumbnails configuration
+	viper.SetDefault("realtime.dashboard.thumbnails.summary", false)
+	viper.SetDefault("realtime.dashboard.thumbnails.recent", true)
+
 	// Retention policy configuration
 	viper.SetDefault("realtime.audio.export.retention.enabled", true)
 	viper.SetDefault("realtime.audio.export.retention.debug", false)

internal/httpcontroller/handlers.go

@@ -1,4 +1,4 @@
-// httpcontroller/handlers.go
+// handlers.go: This file contains the request handlers for the web server.
 package httpcontroller
 
 import (
@@ -152,13 +152,15 @@ func (s *Server) topBirdsHandler(c echo.Context) error {
 
 	// Preparing data for rendering in the template
 	data := struct {
-		NotesWithIndex []NoteWithIndex
-		Hours          []int
-		SelectedDate   string
+		NotesWithIndex    []NoteWithIndex
+		Hours             []int
+		SelectedDate      string
+		DashboardSettings *conf.Dashboard
 	}{
-		NotesWithIndex: notesWithIndex,
-		Hours:          hours,
-		SelectedDate:   selectedDate,
+		NotesWithIndex:    notesWithIndex,
+		Hours:             hours,
+		SelectedDate:      selectedDate,
+		DashboardSettings: s.DashboardSettings,
 	}
 
 	// Render the birdsTableHTML template with the data
@@ -360,13 +362,23 @@ func (s *Server) searchHandler(c echo.Context) error {
 func (s *Server) getLastDetections(c echo.Context) error {
 	numDetections := parseNumDetections(c.QueryParam("numDetections"), 10) // Default value is 10
 
+	// Retrieve the last detections from the database
 	notes, err := s.ds.GetLastDetections(numDetections)
 	if err != nil {
 		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "Error fetching detections"})
 	}
 
+	// Preparing data for rendering in the template
+	data := struct {
+		Notes             []datastore.Note
+		DashboardSettings conf.Dashboard
+	}{
+		Notes:             notes,
+		DashboardSettings: *s.DashboardSettings,
+	}
+
 	// render the recentDetections template with the data
-	return c.Render(http.StatusOK, "recentDetections", notes)
+	return c.Render(http.StatusOK, "recentDetections", data)
 }
 
 // serveSpectrogramHandler serves or generates a spectrogram for a given clip.

internal/httpcontroller/init.go

@@ -28,11 +28,12 @@ func (t *TemplateRenderer) Render(w io.Writer, name string, data interface{}, c
 
 // Server encapsulates Echo server and related configurations.
 type Server struct {
-	Echo           *echo.Echo          // Echo framework instance
-	ds             datastore.Interface // Datastore interface
-	Settings       *conf.Settings      // Application settings
-	Logger         *logger.Logger      // Custom logger
-	BirdImageCache *imageprovider.BirdImageCache
+	Echo              *echo.Echo          // Echo framework instance
+	ds                datastore.Interface // Datastore interface
+	Settings          *conf.Settings      // Application settings
+	DashboardSettings *conf.Dashboard     // Dashboard settings
+	Logger            *logger.Logger      // Custom logger
+	BirdImageCache    *imageprovider.BirdImageCache
 }
 
 // New initializes a new HTTP server with given context and datastore.
@@ -41,10 +42,11 @@ func New(settings *conf.Settings, dataStore datastore.Interface, birdImageCache
 	configureDefaultSettings(settings)
 
 	s := &Server{
-		Echo:           echo.New(),
-		ds:             dataStore,
-		Settings:       settings,
-		BirdImageCache: birdImageCache,
+		Echo:              echo.New(),
+		ds:                dataStore,
+		Settings:          settings,
+		BirdImageCache:    birdImageCache,
+		DashboardSettings: &settings.Realtime.Dashboard,
 	}
 
 	// Server initialization

internal/httpcontroller/utils.go

@@ -1,8 +1,9 @@
-// utils.go
+// utils.go: This file contains utility functions for the HTTP controller package.
 package httpcontroller
 
 import (
 	"fmt"
+	"html"
 	"html/template"
 	"log"
 	"os"
@@ -142,61 +143,6 @@ func (s *Server) getSpectrogramPath(wavFileName string, width int) (string, erro
 	return webFriendlyPath, nil
 }
 
-/*
-// wrapNotesWithSpectrogram wraps notes with their corresponding spectrogram paths.
-func (s *Server) wrapNotesWithSpectrogram(notes []datastore.Note) ([]NoteWithSpectrogram, error) {
-	notesWithSpectrogram := make([]NoteWithSpectrogram, len(notes))
-
-	// Create a channel to communicate between goroutines for results
-	type result struct {
-		index int
-		path  string
-		err   error
-	}
-	results := make(chan result, len(notes))
-
-	// Create a channel to limit the number of concurrent goroutines
-	semaphore := make(chan struct{}, 4) // Limit to 4
-
-	// Set the width of the spectrogram in pixels
-	const width = 400 // pixels
-
-	for i, note := range notes {
-		// Acquire a slot in the semaphore before starting a goroutine
-		semaphore <- struct{}{}
-
-		// Launch a goroutine for each spectrogram generation
-		go func(i int, note datastore.Note) {
-			defer func() { <-semaphore }() // Release the slot when done
-
-			spectrogramPath, err := s.getSpectrogramPath(note.ClipName, width)
-			results <- result{i, spectrogramPath, err}
-		}(i, note)
-	}
-
-	// Wait for all goroutines to finish
-	for i := 0; i < len(notes); i++ {
-		res := <-results
-		if res.err != nil {
-			log.Printf("Error generating spectrogram for %s: %v", notes[res.index].ClipName, res.err)
-			continue
-		}
-		notesWithSpectrogram[res.index] = NoteWithSpectrogram{
-			Note:        notes[res.index],
-			Spectrogram: res.path,
-		}
-	}
-
-	// Wait for all slots to be released ensuring all goroutines have completed
-	for i := 0; i < cap(semaphore); i++ {
-		semaphore <- struct{}{}
-	}
-	close(results)
-	close(semaphore)
-
-	return notesWithSpectrogram, nil
-}*/
-
 // sumHourlyCounts calculates the total counts from hourly counts.
 func sumHourlyCounts(hourlyCounts [24]int) int {
 	total := 0
@@ -239,35 +185,56 @@ func parseOffset(offsetStr string, defaultOffset int) int {
 	return offset
 }
 
-// thumbnail returns the url of a given bird's thumbnail
+// Thumbnail returns the URL of a given bird's thumbnail image.
+// It takes the bird's scientific name as input and returns the image URL as a string.
+// If the image is not found or an error occurs, it returns an empty string.
 func (s *Server) thumbnail(scientificName string) string {
+	if s.BirdImageCache == nil {
+		// Return empty string if the cache is not initialized
+		return ""
+	}
+
 	birdImage, err := s.BirdImageCache.Get(scientificName)
 	if err != nil {
+		// Return empty string if an error occurs
 		return ""
 	}
 
-	return birdImage.Url
+	return birdImage.URL
 }
 
-// thumbnailAttribution returns the thumbnail credits of a given bird.
+// ThumbnailAttribution returns the HTML-formatted attribution for a bird's thumbnail image.
+// It takes the bird's scientific name as input and returns a template.HTML string.
+// If the attribution information is incomplete or an error occurs, it returns an empty template.HTML.
 func (s *Server) thumbnailAttribution(scientificName string) template.HTML {
+	if s.BirdImageCache == nil {
+		// Return empty string if the cache is not initialized
+		return template.HTML("")
+	}
+
 	birdImage, err := s.BirdImageCache.Get(scientificName)
 	if err != nil {
 		log.Printf("Error getting thumbnail info for %s: %v", scientificName, err)
 		return template.HTML("")
 	}
 
-	// Skip if no author or license information
 	if birdImage.AuthorName == "" || birdImage.LicenseName == "" {
 		return template.HTML("")
 	}
 
-	var toReturn string
-	if birdImage.AuthorUrl == "" {
-		toReturn = fmt.Sprintf("© %s / <a href=%s>%s</a>", birdImage.AuthorName, birdImage.LicenseUrl, birdImage.LicenseName)
+	var attribution string
+	if birdImage.AuthorURL == "" {
+		attribution = fmt.Sprintf("© %s / <a href=\"%s\">%s</a>",
+			html.EscapeString(birdImage.AuthorName),
+			html.EscapeString(birdImage.LicenseURL),
+			html.EscapeString(birdImage.LicenseName))
 	} else {
-		toReturn = fmt.Sprintf("© <a href=%s>%s</a> / <a href=%s>%s</a>", birdImage.AuthorUrl, birdImage.AuthorName, birdImage.LicenseUrl, birdImage.LicenseName)
+		attribution = fmt.Sprintf("© <a href=\"%s\">%s</a> / <a href=\"%s\">%s</a>",
+			html.EscapeString(birdImage.AuthorURL),
+			html.EscapeString(birdImage.AuthorName),
+			html.EscapeString(birdImage.LicenseURL),
+			html.EscapeString(birdImage.LicenseName))
 	}
 
-	return template.HTML(toReturn)
+	return template.HTML(attribution)
 }

internal/imageprovider/imageprovider.go

@@ -13,11 +13,11 @@ type ImageProvider interface {
 }
 
 type BirdImage struct {
-	Url         string
+	URL         string
 	LicenseName string
-	LicenseUrl  string
+	LicenseURL  string
 	AuthorName  string
-	AuthorUrl   string
+	AuthorURL   string
 }
 
 // BirdImageCache represents a cache for bird images.
@@ -112,9 +112,9 @@ func (c *BirdImageCache) fetch(scientificName string) (BirdImage, error) {
 // EstimateSize estimates the memory size of a BirdImage instance in bytes
 func (img *BirdImage) EstimateSize() int {
 	return int(unsafe.Sizeof(*img)) +
-		len(img.Url) + len(img.LicenseName) +
-		len(img.LicenseUrl) + len(img.AuthorName) +
-		len(img.AuthorUrl)
+		len(img.URL) + len(img.LicenseName) +
+		len(img.LicenseURL) + len(img.AuthorName) +
+		len(img.AuthorURL)
 }
 
 // MemoryUsage returns the approximate memory usage of the image cache in bytes