Merge branch 'dev' of https://github.com/blakeblackshear/frigate into addon_config

docs/docs/configuration/advanced.md

@@ -172,6 +172,38 @@ listen [::]:8971 ipv6only=off ssl;
 listen [::]:5000 ipv6only=off;
 ```
 
+## Base path
+
+By default, Frigate runs at the root path (`/`). However some setups require to run Frigate under a custom path prefix (e.g. `/frigate`), especially when Frigate is located behind a reverse proxy that requires path-based routing.
+
+### Set Base Path via HTTP Header
+The preferred way to configure the base path is through the `X-Ingress-Path` HTTP header, which needs to be set to the desired base path in an upstream reverse proxy.
+
+For example, in Nginx:
+```
+location /frigate {
+    proxy_set_header X-Ingress-Path /frigate;
+    proxy_pass http://frigate_backend;
+}
+```
+
+### Set Base Path via Environment Variable
+When it is not feasible to set the base path via a HTTP header, it can also be set via the `FRIGATE_BASE_PATH` environment variable in the Docker Compose file.
+
+For example:
+```
+services:
+  frigate:
+    image: blakeblackshear/frigate:latest
+    environment:
+      - FRIGATE_BASE_PATH=/frigate
+```
+
+This can be used for example to access Frigate via a Tailscale agent (https), by simply forwarding all requests to the base path (http):
+```
+tailscale serve --https=443 --bg --set-path /frigate http://localhost:5000/frigate
+```
+
 ## Custom Dependencies
 
 ### Custom ffmpeg build

docs/docs/configuration/face_recognition.md

@@ -3,19 +3,55 @@ id: face_recognition
 title: Face Recognition
 ---
 
-Face recognition allows people to be assigned names and when their face is recognized Frigate will assign the person's name as a sub label. This information is included in the UI, filters, as well as in notifications.
+Face recognition identifies known individuals by matching detected faces with previously learned facial data. When a known person is recognized, their name will be added as a `sub_label`. This information is included in the UI, filters, as well as in notifications.
+
+## Model Requirements
 
 Frigate has support for CV2 Local Binary Pattern Face Recognizer to recognize faces, which runs locally. A lightweight face landmark detection model is also used to align faces before running them through the face recognizer.
 
+Users running a Frigate+ model (or any custom model that natively detects faces) should ensure that `face` is added to the [list of objects to track](../plus/#available-label-types) either globally or for a specific camera. This will allow face detection to run at the same time as object detection and be more efficient.
+
+Users without a model that detects faces can still run face recognition. Frigate uses a lightweight DNN face detection model that runs on the CPU. In this case, you should _not_ define `face` in your list of objects to track.
+
+:::note
+
+Frigate needs to first detect a `face` before it can recognize a face.
+
+:::
+
+## Minimum System Requirements
+
+Face recognition is lightweight and runs on the CPU, there are no significantly different system requirements than running Frigate itself.
+
 ## Configuration
 
-Face recognition is disabled by default, face recognition must be enabled in your config file before it can be used. Face recognition is a global configuration setting.
+Face recognition is disabled by default, face recognition must be enabled in the UI or in your config file before it can be used. Face recognition is a global configuration setting.
 
 ```yaml
 face_recognition:
   enabled: true
 ```
 
+## Advanced Configuration
+
+Fine-tune face recognition with these optional parameters:
+
+### Detection
+
+- `detection_threshold`: Face detection confidence score required before recognition runs:
+  - Default: `0.7`
+  - Note: This is field only applies to the standalone face detection model, `min_score` should be used to filter for models that have face detection built in.
+- `min_area`: Defines the minimum size (in pixels) a face must be before recognition runs.
+  - Default: `500` pixels.
+  - Depending on the resolution of your camera's `detect` stream, you can increase this value to ignore small or distant faces.
+
+### Recognition
+
+- `recognition_threshold`: Recognition confidence score required to add the face to the object as a sub label.
+  - Default: `0.9`.
+- `blur_confidence_filter`: Enables a filter that calculates how blurry the face is and adjusts the confidence based on this.
+  - Default: `True`.
+
 ## Dataset
 
 The number of images needed for a sufficient training set for face recognition varies depending on several factors:

docs/docs/configuration/license_plate_recognition.md

@@ -51,16 +51,16 @@ Fine-tune the LPR feature using these optional parameters:
 
 - **`detection_threshold`**: License plate object detection confidence score required before recognition runs.
   - Default: `0.7`
-  - Note: If you are using a Frigate+ model and you set the `threshold` in your objects config for `license_plate` higher than this value, recognition will never run. It's best to ensure these values match, or this `detection_threshold` is lower than your object config `threshold`.
+  - Note: This is field only applies to the standalone license plate detection model, `min_score` should be used to filter for models that have license plate detection built in.
 - **`min_area`**: Defines the minimum size (in pixels) a license plate must be before recognition runs.
   - Default: `1000` pixels.
   - Depending on the resolution of your camera's `detect` stream, you can increase this value to ignore small or distant plates.
 
 ### Recognition
 
-- **`recognition_threshold`**: Recognition confidence score required to add the plate to the object as a sub label.
+- **`recognition_threshold`**: Recognition confidence score required to add the plate to the object as a `recognized_license_plate` and/or `sub_label`.
   - Default: `0.9`.
-- **`min_plate_length`**: Specifies the minimum number of characters a detected license plate must have to be added as a sub label to an object.
+- **`min_plate_length`**: Specifies the minimum number of characters a detected license plate must have to be added as a `recognized_license_plate` and/or `sub_label` to an object.
   - Use this to filter out short, incomplete, or incorrect detections.
 - **`format`**: A regular expression defining the expected format of detected plates. Plates that do not match this format will be discarded.
   - `"^[A-Z]{1,3} [A-Z]{1,2} [0-9]{1,4}$"` matches plates like "B AB 1234" or "M X 7"

docs/docs/configuration/object_detectors.md

@@ -129,8 +129,8 @@ detectors:
     type: edgetpu
     device: pci
 ```
----
 
+---
 
 ## Hailo-8
 
@@ -140,12 +140,13 @@ See the [installation docs](../frigate/installation.md#hailo-8l) for information
 
 ### Configuration
 
-When configuring the Hailo detector, you have two options to specify the model: a local **path** or a **URL**.  
+When configuring the Hailo detector, you have two options to specify the model: a local **path** or a **URL**.
 If both are provided, the detector will first check for the model at the given local path. If the file is not found, it will download the model from the specified URL. The model file is cached under `/config/model_cache/hailo`.
 
-#### YOLO 
+#### YOLO
 
 Use this configuration for YOLO-based models. When no custom model path or URL is provided, the detector automatically downloads the default model based on the detected hardware:
+
 - **Hailo-8 hardware:** Uses **YOLOv6n** (default: `yolov6n.hef`)
 - **Hailo-8L hardware:** Uses **YOLOv6n** (default: `yolov6n.hef`)
 
@@ -224,17 +225,16 @@ model:
   # Alternatively, or as a fallback, provide a custom URL:
   # path: https://custom-model-url.com/path/to/model.hef
 ```
+
 For additional ready-to-use models, please visit: https://github.com/hailo-ai/hailo_model_zoo
 
-Hailo8 supports all models in the Hailo Model Zoo that include HailoRT post-processing. You're welcome to choose any of these pre-configured models for your implementation. 
+Hailo8 supports all models in the Hailo Model Zoo that include HailoRT post-processing. You're welcome to choose any of these pre-configured models for your implementation.
 
-> **Note:**  
+> **Note:**
 > The config.path parameter can accept either a local file path or a URL ending with .hef. When provided, the detector will first check if the path is a local file path. If the file exists locally, it will use it directly. If the file is not found locally or if a URL was provided, it will attempt to download the model from the specified URL.
 
 ---
 
-
-
 ## OpenVINO Detector
 
 The OpenVINO detector type runs an OpenVINO IR model on AMD and Intel CPUs, Intel GPUs and Intel VPU hardware. To configure an OpenVINO detector, set the `"type"` attribute to `"openvino"`.
@@ -340,6 +340,30 @@ model:
 
 Note that the labelmap uses a subset of the complete COCO label set that has only 80 objects.
 
+#### D-FINE
+
+[D-FINE](https://github.com/Peterande/D-FINE) is the [current state of the art](https://paperswithcode.com/sota/real-time-object-detection-on-coco?p=d-fine-redefine-regression-task-in-detrs-as) at the time of writing. The ONNX exported models are supported, but not included by default. See [the models section](#downloading-d-fine-model) for more information on downloading the D-FINE model for use in Frigate.
+
+After placing the downloaded onnx model in your config/model_cache folder, you can use the following configuration:
+
+```yaml
+detectors:
+  ov:
+    type: openvino
+    device: GPU
+
+model:
+  model_type: dfine
+  width: 640
+  height: 640
+  input_tensor: nchw
+  input_dtype: float
+  path: /config/model_cache/dfine_s_obj2coco.onnx
+  labelmap_path: /labelmap/coco-80.txt
+```
+
+Note that the labelmap uses a subset of the complete COCO label set that has only 80 objects.
+
 ## NVidia TensorRT Detector
 
 Nvidia GPUs may be used for object detection using the TensorRT libraries. Due to the size of the additional libraries, this detector is only provided in images with the `-tensorrt` tag suffix, e.g. `ghcr.io/blakeblackshear/frigate:stable-tensorrt`. This detector is designed to work with Yolo models for object detection.
@@ -529,6 +553,7 @@ $ docker exec -it frigate /bin/bash -c '(unset HSA_OVERRIDE_GFX_VERSION && /opt/
 ### Supported Models
 
 See [ONNX supported models](#supported-models) for supported models, there are some caveats:
+
 - D-FINE models are not supported
 - YOLO-NAS models are known to not run well on integrated GPUs
 
@@ -626,12 +651,6 @@ Note that the labelmap uses a subset of the complete COCO label set that has onl
 
 [D-FINE](https://github.com/Peterande/D-FINE) is the [current state of the art](https://paperswithcode.com/sota/real-time-object-detection-on-coco?p=d-fine-redefine-regression-task-in-detrs-as) at the time of writing. The ONNX exported models are supported, but not included by default. See [the models section](#downloading-d-fine-model) for more information on downloading the D-FINE model for use in Frigate.
 
-:::warning
-
-D-FINE is currently not supported on OpenVINO
-
-:::
-
 After placing the downloaded onnx model in your config/model_cache folder, you can use the following configuration:
 
 ```yaml

docs/docs/configuration/reference.md

@@ -543,12 +543,23 @@ semantic_search:
   model_size: "small"
 
 # Optional: Configuration for face recognition capability
+# NOTE: Can (enabled, min_area) be overridden at the camera level
 face_recognition:
   # Optional: Enable semantic search (default: shown below)
   enabled: False
-  # Optional: Set the model size used for embeddings. (default: shown below)
-  # NOTE: small model runs on CPU and large model runs on GPU
-  model_size: "small"
+  # Optional: Minimum face distance score required to save the attempt (default: shown below)
+  min_score: 0.8
+  # Optional: Minimum face detection score required to detect a face (default: shown below)
+  # NOTE: This only applies when not running a Frigate+ model
+  detection_threshold: 0.7
+  # Optional: Minimum face distance score required to be considered a match (default: shown below)
+  recognition_threshold: 0.9
+  # Optional: Min area of detected face box to consider running face recognition (default: shown below)
+  min_area: 500
+  # Optional: Save images of recognized faces for training (default: shown below)
+  save_attempts: True
+  # Optional: Apply a blur quality filter to adjust confidence based on the blur level of the image (default: shown below)
+  blur_confidence_filter: True
 
 # Optional: Configuration for license plate recognition capability
 lpr:

docs/docs/development/contributing-boards.md

@@ -72,17 +72,17 @@ COPY --from=rootfs / /
 The images for each board will be built for each Frigate release, this is done in the `.github/workflows/ci.yml` file. The board build workflow will need to be added here.
 
 ```yml
-      - name: Build and push board build
-        uses: docker/bake-action@v3
-        with:
-          push: true
-          targets: board # this is the target in the board.hcl file
-          files: docker/board/board.hcl # this should be updated with the actual board type
-          # the tags should be updated with the actual board types as well
-          # the community board builds should never push to cache, but it can pull from cache
-          set: |
-            board.tags=ghcr.io/${{ steps.lowercaseRepo.outputs.lowercase }}:${{ github.ref_name }}-${{ env.SHORT_SHA }}-board
-            *.cache-from=type=gha
+- name: Build and push board build
+  uses: docker/bake-action@v3
+  with:
+    push: true
+    targets: board # this is the target in the board.hcl file
+    files: docker/board/board.hcl # this should be updated with the actual board type
+    # the tags should be updated with the actual board types as well
+    # the community board builds should never push to cache, but it can pull from cache
+    set: |
+      board.tags=ghcr.io/${{ steps.lowercaseRepo.outputs.lowercase }}:${{ github.ref_name }}-${{ env.SHORT_SHA }}-board
+      *.cache-from=type=gha
 ```
 
 ### Code Owner File

docs/docs/development/contributing.md

@@ -235,3 +235,14 @@ When testing nginx config changes from within the dev container, the following c
 ```console
 sudo cp docker/main/rootfs/usr/local/nginx/conf/* /usr/local/nginx/conf/ && sudo /usr/local/nginx/sbin/nginx -s reload
 ```
+
+## Contributing translations of the Web UI
+
+If you'd like to contribute translations to Frigate, please follow these steps:
+
+1. Fork the repository and create a new branch specifically for your translation work
+2. Locate the localization files in the web/public/locales directory
+3. Add or modify the appropriate language JSON files, maintaining the existing key structure while translating only the values
+4. Ensure your translations maintain proper formatting, including any placeholder variables (like `{{example}}`)
+5. Before submitting, thoroughly review the UI
+6. When creating your PR, include a brief description of the languages you've added or updated, and reference any related issues

docs/docs/integrations/mqtt.md

@@ -305,6 +305,10 @@ Topic to adjust motion contour area for a camera. Expected value is an integer.
 
 Topic with current motion contour area for a camera. Published value is an integer.
 
+### `frigate/<camera_name>/review_status`
+
+Topic with current activity status of the camera. Possible values are `NONE`, `DETECTION`, or `ALERT`.
+
 ### `frigate/<camera_name>/ptz`
 
 Topic to send PTZ commands to camera.

docs/docs/plus/faq.md

@@ -22,3 +22,13 @@ Yes. Models and metadata are stored in the `model_cache` directory within the co
 ### Can I keep using my Frigate+ models even if I do not renew my subscription?
 
 Yes. Subscriptions to Frigate+ provide access to the infrastructure used to train the models. Models trained with your subscription are yours to keep and use forever. However, do note that the terms and conditions prohibit you from sharing, reselling, or creating derivative products from the models.
+
+### Why can't I submit images to Frigate+?
+
+If you've configured your API key and the Frigate+ Settings page in the UI shows that the key is active, you need to ensure that you've enabled both snapshots and `clean_copy` snapshots for the cameras you'd like to submit images for. Note that `clean_copy` is enabled by default when snapshots are enabled.
+
+```yaml
+snapshots:
+  enabled: true
+  clean_copy: true
+```